alga2 0.1.0

A modern abstract-algebra hierarchy for Rust — the successor to alga, powered by batch-impl
Documentation 
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
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Transformations of points/vectors (alga-aligned interface).
//!
//! The transformation hierarchy — plain, projective, affine, similarity —
//! describes how a transformation acts on an [`EuclideanSpace`]: points and
//! vectors are transformed separately, and the richer classes decompose
//! into translation / rotation / scaling. Like the matrix traits, these are
//! an interface for downstream geometry types.

use crate::tower::EuclideanSpace;

/// A transformation of an euclidean space: acts on both points and vectors.
pub trait Transformation<E: EuclideanSpace>: Sized + Clone {
    /// Transforms a point.
    fn transform_point(&self, pt: &E) -> E;

    /// Transforms a vector (the coordinate part).
    fn transform_vector(&self, v: &E::Coordinates) -> E::Coordinates;
}

/// A projective transformation: invertible.
pub trait ProjectiveTransformation<E: EuclideanSpace>: Transformation<E> {
    /// The inverse transformation.
    fn inverse_transform(&self) -> Self;

    /// Transforms a point by the inverse.
    fn inverse_transform_point(&self, pt: &E) -> E {
        self.inverse_transform().transform_point(pt)
    }

    /// Transforms a vector by the inverse.
    fn inverse_transform_vector(&self, v: &E::Coordinates) -> E::Coordinates {
        self.inverse_transform().transform_vector(v)
    }
}

/// An affine transformation: decomposes into translation, rotation, scaling.
pub trait AffineTransformation<E: EuclideanSpace>: ProjectiveTransformation<E> {
    /// The rotation part type.
    type Rotation: Rotation<E>;

    /// The non-uniform scaling part type.
    type NonUniformScaling: AffineTransformation<E>;

    /// The translation part type.
    type Translation: Translation<E>;

    /// Decomposes into `(translation, rotation, non-uniform scaling)`.
    fn decompose(&self) -> (Self::Translation, Self::Rotation, Self::NonUniformScaling);

    /// Appends a translation.
    fn append_translation(&self, t: &Self::Translation) -> Self;

    /// Prepends a translation.
    fn prepend_translation(&self, t: &Self::Translation) -> Self;

    /// Appends a rotation.
    fn append_rotation(&self, r: &Self::Rotation) -> Self;

    /// Prepends a rotation.
    fn prepend_rotation(&self, r: &Self::Rotation) -> Self;

    /// Appends a non-uniform scaling.
    fn append_scaling(&self, s: &Self::NonUniformScaling) -> Self;

    /// Prepends a non-uniform scaling.
    fn prepend_scaling(&self, s: &Self::NonUniformScaling) -> Self;
}

/// A similarity transformation: uniform scaling + rotation + translation.
pub trait Similarity<E: EuclideanSpace>: AffineTransformation<E> {
    /// The uniform scaling part type.
    type Scaling: Scaling<E>;

    /// The translation part.
    fn translation(&self) -> Self::Translation;

    /// The rotation part.
    fn rotation(&self) -> Self::Rotation;

    /// The uniform scaling part.
    fn scaling(&self) -> Self::Scaling;

    /// Translates a point.
    fn translate_point(&self, pt: &E) -> E {
        <Self::Translation as Translation<E>>::transform_point(&self.translation(), pt)
    }

    /// Rotates a point.
    fn rotate_point(&self, pt: &E) -> E {
        <Self::Rotation as Transformation<E>>::transform_point(&self.rotation(), pt)
    }

    /// Uniformly scales a point.
    fn scale_point(&self, pt: &E) -> E {
        <Self::Scaling as Transformation<E>>::transform_point(&self.scaling(), pt)
    }
}

/// A rotation: preserves norms and orientation.
pub trait Rotation<E: EuclideanSpace>: Transformation<E> {}

/// An isometry: a similarity with unit scaling (preserves distances).
pub trait Isometry<E: EuclideanSpace>: Similarity<E> {}

/// A direct isometry: an isometry preserving orientation.
pub trait DirectIsometry<E: EuclideanSpace>: Isometry<E> {}

/// An orthogonal transformation: preserves the inner product — a linear
/// isometry fixing the origin.
pub trait OrthogonalTransformation<E: EuclideanSpace>: Transformation<E> {}

/// A (possibly non-uniform) scaling.
pub trait Scaling<E: EuclideanSpace>: Transformation<E> {}

/// A translation: moves points by a vector, leaves vectors untouched.
pub trait Translation<E: EuclideanSpace>: Transformation<E> {
    /// The translation vector.
    fn translation_vector(&self) -> E::Coordinates;

    /// Applies to a point.
    fn transform_point(&self, pt: &E) -> E {
        E::from_coordinates(<E::Coordinates as crate::tower::Magma<crate::op::Additive>>::combine(
            &pt.coordinates(),
            &self.translation_vector(),
        ))
    }

    /// Applies to a vector (the identity).
    fn transform_vector(&self, v: &E::Coordinates) -> E::Coordinates {
        <E::Coordinates as Clone>::clone(v)
    }
}