constraint.rs - source
Description: Source of the Rust file `/Users/erlendbasso/.cargo/registry/src/github.com-1ecc6299db9ec823/nalgebra-0.32.1/src/base/constraint.rs`.
Keywords: rust, rustlang, rust-lang

    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
    90
    91

    //! Compatibility constraints between matrix shapes, e.g., for addition or multiplication.

    use crate::base::dimension::{Dim, DimName, Dyn};

    /// A type used in `where` clauses for enforcing constraints.
    #[derive(Copy, Clone, Debug)]
    pub struct ShapeConstraint;

    /// Constraints `C1` and `R2` to be equivalent.
    pub trait AreMultipliable<R1: Dim, C1: Dim, R2: Dim, C2: Dim>: DimEq<C1, R2> {}

    impl<R1: Dim, C1: Dim, R2: Dim, C2: Dim> AreMultipliable<R1, C1, R2, C2> for ShapeConstraint where
        ShapeConstraint: DimEq<C1, R2>
    {
    }

    /// Constraints `D1` and `D2` to be equivalent.
    pub trait DimEq<D1: Dim, D2: Dim> {
        /// This is either equal to `D1` or `D2`, always choosing the one (if any) which is a type-level
        /// constant.
        type Representative: Dim;
    }

    impl<D: Dim> DimEq<D, D> for ShapeConstraint {
        type Representative = D;
    }

    impl<D: DimName> DimEq<D, Dyn> for ShapeConstraint {
        type Representative = D;
    }

    impl<D: DimName> DimEq<Dyn, D> for ShapeConstraint {
        type Representative = D;
    }

    macro_rules! equality_trait_decl(
        ($($doc: expr, $Trait: ident),* $(,)*) => {$(
            // XXX: we can't do something like `DimEq<D1> for D2` because we would require a blancket impl…
            #[doc = $doc]
            pub trait $Trait<D1: Dim, D2: Dim>: DimEq<D1, D2> + DimEq<D2, D1> {
                /// This is either equal to `D1` or `D2`, always choosing the one (if any) which is a type-level
                /// constant.
                type Representative: Dim;
            }

            impl<D: Dim> $Trait<D, D> for ShapeConstraint {
                type Representative = D;
            }

            impl<D: DimName> $Trait<D, Dyn> for ShapeConstraint {
                type Representative = D;
            }

            impl<D: DimName> $Trait<Dyn, D> for ShapeConstraint {
                type Representative = D;
            }
        )*}
    );

    equality_trait_decl!(
        "Constraints `D1` and `D2` to be equivalent. \
         They are both assumed to be the number of \
         rows of a matrix.",
        SameNumberOfRows,
        "Constraints `D1` and `D2` to be equivalent. \
         They are both assumed to be the number of \
         columns of a matrix.",
        SameNumberOfColumns
    );

    /// Constraints D1 and D2 to be equivalent, where they both designate dimensions of algebraic
    /// entities (e.g. square matrices).
    pub trait SameDimension<D1: Dim, D2: Dim>:
        SameNumberOfRows<D1, D2> + SameNumberOfColumns<D1, D2>
    {
        /// This is either equal to `D1` or `D2`, always choosing the one (if any) which is a type-level
        /// constant.
        type Representative: Dim;
    }

    impl<D: Dim> SameDimension<D, D> for ShapeConstraint {
        type Representative = D;
    }

    impl<D: DimName> SameDimension<D, Dyn> for ShapeConstraint {
        type Representative = D;
    }

    impl<D: DimName> SameDimension<Dyn, D> for ShapeConstraint {
        type Representative = D;
    }