vmm 0.2.1

A math library focused on vectors and square matrices (Not in development)
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

use super::MatN;
use crate::types::{math::*, vectors::{VecN, Vec3}};

impl<T, const N: usize> ScalarMath<T> for MatN<T, N>
where 
    T: Default + Copy
        + std::ops::Add<Output = T>
        + std::ops::Sub<Output = T>
        + std::ops::Mul<Output = T>
        + std::ops::Div<Output = T>,
{
    fn sum_scalar(&self, value: T) -> Self 
    {
        let mut result = self.clone();

        for val in result.data.iter_mut()
        {
            *val = val.sum_scalar(value);
        } 
        
        result
    }
    fn sub_scalar(&self, value: T) -> Self 
    {
        let mut result = self.clone();
        
        for val in result.data.iter_mut()
        {
            *val = val.sub_scalar(value);
        }
        
        result
    }
    fn mul_scalar(&self, value: T) -> Self 
    {
        let mut result = self.clone();
        
        for val in result.data.iter_mut()
        {
            *val = val.mul_scalar(value);
        }
        
        result
    }    
    fn div_scalar(&self, value: T) -> Self 
    {
        let mut result = self.clone();
        
        for val in result.data.iter_mut()
        {
            *val = val.div_scalar(value);
        }
        
        result
    }
}

pub trait Identity
{
    /// Creates an identity matrix of size N.
    ///
    /// An identity matrix is a square matrix with ones on the main diagonal and zeros elsewhere.
    ///
    /// # Returns
    ///
    /// A new identity matrix of size N.
    ///
    /// # Examples
    ///
    /// ```
    /// # use vmm::*;
    /// 
    /// let mat = MatN::<f64, 2>::identity();
    /// 
    /// assert_eq!(mat.to_mat(), [[1.0, 0.0], [0.0, 1.0]]);
    /// ```
    ///
    /// # Notes
    ///
    /// - The identity matrix is a special case of a diagonal matrix where all diagonal elements are 1.
    /// - This method assumes that the element type `T` supports conversion from `f64`.
    fn identity() -> Self;
}
pub trait MatVecMath<T, const N: usize>
where
    T: Default + Copy,
{
    /// Multiplies the matrix by a vector.
    ///
    /// This method performs matrix-vector multiplication, resulting in a new vector.
    ///
    /// # Arguments
    ///
    /// * `vec` - The vector to multiply with the matrix.
    ///
    /// # Returns
    ///
    /// A new vector (`VecN`) representing the result of the matrix-vector multiplication.
    ///
    /// # Examples
    ///
    /// ```
    /// # use vmm::*;
    /// let mat = mat2_raw![[1.0, 2.0], [3.0, 4.0]];
    /// let vec = vec2![5.0, 6.0];
    /// 
    /// assert_eq!(mat.mul_mat_vec(&vec).to_arr(), &[17.0, 39.0]);
    /// ```
    ///
    /// # Notes
    ///
    /// - Matrix-vector multiplication is performed by multiplying each row of the matrix by the corresponding
    ///   element of the vector and summing the results.
    /// - This method assumes that the element type `T` supports multiplication and addition.
    /// - The resulting vector is of the same size as the input vector.
    ///
    /// # See Also
    ///
    /// - [`VecN`]: The vector type used by this method.
    fn mul_mat_vec(&self, vec: &VecN<T, N>) -> VecN<T, N>;
}
pub trait MatTransforms<T, const N: usize>
where
    T: Default + Copy,
{
    /// Creates a `translation` matrix and multiplies with `self`, it is dependent on the matrix dimension. 
    fn translate(&self, vec: &VecN<T, N>) -> Self;
    /// Creates a `rotation` matrix and multiplies with `self`, it is dependent on the matrix dimension.
    fn rotate(&self, angle: T, axis: &Vec3<T>) -> Self;
    /// Creates a `scaling` matrix and multiplies with `self`, it is dependent on the matrix dimension.
    fn scale(&self, values: &Vec3<T>) -> Self;
}