1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Abstract definition of a matrix data storage allocator.

use std::any::Any;

use core::Scalar;
use core::constraint::{SameNumberOfRows, SameNumberOfColumns, ShapeConstraint};
use core::dimension::{Dim, U1};
use core::storage::{Storage, OwnedStorage};

/// A matrix allocator of a memory buffer that may contain `R::to_usize() * C::to_usize()`
/// elements of type `N`.
///
/// An allocator is said to be:
///   − static:  if `R` and `C` both implement `DimName`.
///   − dynamic: if either one (or both) of `R` or `C` is equal to `Dynamic`.
///
/// Every allocator must be both static and dynamic. Though not all implementations may share the
/// same `Buffer` type.
pub trait Allocator<N: Scalar, R: Dim, C: Dim>: Any + Sized {
    /// The type of buffer this allocator can instanciate.
    type Buffer: OwnedStorage<N, R, C, Alloc = Self>;

    /// Allocates a buffer with the given number of rows and columns without initializing its content.
    unsafe fn allocate_uninitialized(nrows: R, ncols: C) -> Self::Buffer;

    /// Allocates a buffer initialized with the content of the given iterator.
    fn allocate_from_iterator<I: IntoIterator<Item = N>>(nrows: R, ncols: C, iter: I) -> Self::Buffer;
}

/// A matrix data allocator dedicated to the given owned matrix storage.
pub trait OwnedAllocator<N: Scalar, R: Dim, C: Dim, S: OwnedStorage<N, R, C, Alloc = Self>>:
    Allocator<N, R, C, Buffer = S> {
}

impl<N, R, C, T, S> OwnedAllocator<N, R, C, S> for T
    where N: Scalar, R: Dim, C: Dim,
          T: Allocator<N, R, C, Buffer = S>,
          S: OwnedStorage<N, R, C, Alloc = T> {
}

/// The number of rows of the result of a componentwise operation on two matrices.
pub type SameShapeR<R1, R2> = <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative;

/// The number of columns of the result of a componentwise operation on two matrices.
pub type SameShapeC<C1, C2> = <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative;

// FIXME: Bad name.
/// Restricts the given number of rows and columns to be respectively the same. Can only be used
/// when `Self = SA::Alloc`.
pub trait SameShapeAllocator<N, R1, C1, R2, C2, SA>:
        Allocator<N, R1, C1> +
        Allocator<N, SameShapeR<R1, R2>, SameShapeC<C1, C2>>
    where R1: Dim, R2: Dim, C1: Dim, C2: Dim,
          N: Scalar,
          SA: Storage<N, R1, C1, Alloc = Self>,
          ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
}

impl<N, R1, R2, C1, C2, SA> SameShapeAllocator<N, R1, C1, R2, C2, SA> for SA::Alloc
    where R1: Dim, R2: Dim, C1: Dim, C2: Dim,
          N: Scalar,
          SA: Storage<N, R1, C1>,
          SA::Alloc:
            Allocator<N, R1, C1> +
            Allocator<N, SameShapeR<R1, R2>, SameShapeC<C1, C2>>,
          ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
}

// XXX: Bad name.
/// Restricts the given number of rows to be equal. Can only be used when `Self = SA::Alloc`.
pub trait SameShapeColumnVectorAllocator<N, R1, R2, SA>:
        Allocator<N, R1, U1> +
        Allocator<N, SameShapeR<R1, R2>, U1> +
        SameShapeAllocator<N, R1, U1, R2, U1, SA>
    where R1: Dim, R2: Dim,
          N: Scalar,
          SA: Storage<N, R1, U1, Alloc = Self>,
          ShapeConstraint: SameNumberOfRows<R1, R2> {
}

impl<N, R1, R2, SA> SameShapeColumnVectorAllocator<N, R1, R2, SA> for SA::Alloc
    where R1: Dim, R2: Dim,
          N: Scalar,
          SA: Storage<N, R1, U1>,
          SA::Alloc:
            Allocator<N, R1, U1> +
            Allocator<N, SameShapeR<R1, R2>, U1>,
          ShapeConstraint: SameNumberOfRows<R1, R2> {
}