translation_ops.rs - source
Description: Source of the Rust file `/Users/erlendbasso/.cargo/registry/src/github.com-1ecc6299db9ec823/nalgebra-0.32.1/src/geometry/translation_ops.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
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119

    use std::ops::{Div, DivAssign, Mul, MulAssign};

    use simba::scalar::{ClosedAdd, ClosedSub};

    use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
    use crate::base::dimension::U1;
    use crate::base::{Const, Scalar};

    use crate::geometry::{Point, Translation};

    // Translation × Translation
    add_sub_impl!(Mul, mul, ClosedAdd;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + &right.vector) };
        'a, 'b);

    add_sub_impl!(Mul, mul, ClosedAdd;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + right.vector) };
        'a);

    add_sub_impl!(Mul, mul, ClosedAdd;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector + &right.vector) };
        'b);

    add_sub_impl!(Mul, mul, ClosedAdd;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector + right.vector) }; );

    // Translation ÷ Translation
    // TODO: instead of calling inverse explicitly, could we just add a `mul_tr` or `mul_inv` method?
    add_sub_impl!(Div, div, ClosedSub;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - &right.vector) };
        'a, 'b);

    add_sub_impl!(Div, div, ClosedSub;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - right.vector) };
        'a);

    add_sub_impl!(Div, div, ClosedSub;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector - &right.vector) };
        'b);

    add_sub_impl!(Div, div, ClosedSub;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector - right.vector) }; );

    // Translation × Point
    // TODO: we don't handle properly non-zero origins here. Do we want this to be the intended
    // behavior?
    add_sub_impl!(Mul, mul, ClosedAdd;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: &'a Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
        'a, 'b);

    add_sub_impl!(Mul, mul, ClosedAdd;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: &'a Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
        'a);

    add_sub_impl!(Mul, mul, ClosedAdd;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector };
        'b);

    add_sub_impl!(Mul, mul, ClosedAdd;
        (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
        const D; for; where;
        self: Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
        #[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector }; );

    // Translation *= Translation
    add_sub_assign_impl!(MulAssign, mul_assign, ClosedAdd;
        const D;
        self: Translation<T, D>, right: &'b Translation<T, D>;
        #[allow(clippy::suspicious_op_assign_impl)] { self.vector += &right.vector };
        'b);

    add_sub_assign_impl!(MulAssign, mul_assign, ClosedAdd;
        const D;
        self: Translation<T, D>, right: Translation<T, D>;
        #[allow(clippy::suspicious_op_assign_impl)] { self.vector += right.vector }; );

    add_sub_assign_impl!(DivAssign, div_assign, ClosedSub;
        const D;
        self: Translation<T, D>, right: &'b Translation<T, D>;
        #[allow(clippy::suspicious_op_assign_impl)] { self.vector -= &right.vector };
        'b);

    add_sub_assign_impl!(DivAssign, div_assign, ClosedSub;
        const D;
        self: Translation<T, D>, right: Translation<T, D>;
        #[allow(clippy::suspicious_op_assign_impl)] { self.vector -= right.vector }; );