mech_core/
matrix.rs

1use crate::*;
2use crate::types::Ref;
3use na::{Vector3, DVector, Vector2, Vector4, RowDVector, Matrix1, Matrix3, Matrix4, RowVector3, RowVector4, RowVector2, DMatrix, Rotation3, Matrix2x3, Matrix3x2, Matrix6, Matrix2};
4use tabled::{
5    builder::Builder,
6    settings::{object::Rows,Panel, Span, Alignment, Modify, Style},
7    Tabled,
8  };
9use std::fmt::{Debug, Display};
10use std::hash::{Hash, Hasher};
11use std::slice::Iter;
12use std::iter::Peekable;
13use serde::ser::{Serialize, Serializer, SerializeStruct};
14
15// Matrix ---------------------------------------------------------------------
16
17pub trait ToMatrix: Clone {
18  fn to_matrix(elements: Vec<Self>, rows: usize, cols: usize) -> Matrix<Self>;
19}
20  
21macro_rules! impl_to_matrix {
22  ($t:ty) => {
23    impl ToMatrix for $t {
24      fn to_matrix(elements: Vec<Self>, rows: usize, cols: usize) -> Matrix<Self> {
25        match (rows,cols) {
26          #[cfg(feature = "Matrix1")]
27          (1,1) => Matrix::Matrix1(new_ref(Matrix1::from_element(elements[0].clone()))),
28          #[cfg(feature = "Matrix2")]
29          (2,2) => Matrix::Matrix2(new_ref(Matrix2::from_vec(elements))),
30          #[cfg(feature = "Matrix3")]
31          (3,3) => Matrix::Matrix3(new_ref(Matrix3::from_vec(elements))),
32          #[cfg(feature = "Matrix4")]
33          (4,4) => Matrix::Matrix4(new_ref(Matrix4::from_vec(elements))),
34          #[cfg(feature = "Matrix2x3")]
35          (2,3) => Matrix::Matrix2x3(new_ref(Matrix2x3::from_vec(elements))),
36          #[cfg(feature = "Matrix3x2")]
37          (3,2) => Matrix::Matrix3x2(new_ref(Matrix3x2::from_vec(elements))),
38          #[cfg(feature = "RowVector2")]
39          (1,2) => Matrix::RowVector2(new_ref(RowVector2::from_vec(elements))),
40          #[cfg(feature = "RowVector3")]
41          (1,3) => Matrix::RowVector3(new_ref(RowVector3::from_vec(elements))),
42          #[cfg(feature = "RowVector4")]
43          (1,4) => Matrix::RowVector4(new_ref(RowVector4::from_vec(elements))),
44          #[cfg(feature = "Vector2")]
45          (2,1) => Matrix::Vector2(new_ref(Vector2::from_vec(elements))),
46          #[cfg(feature = "Vector2")]
47          (3,1) => Matrix::Vector3(new_ref(Vector3::from_vec(elements))),
48          #[cfg(feature = "Vector2")]
49          (4,1) => Matrix::Vector4(new_ref(Vector4::from_vec(elements))),
50          #[cfg(feature = "RowVectorD")]
51          (1,n) => Matrix::RowDVector(new_ref(RowDVector::from_vec(elements))),
52          #[cfg(feature = "VectorD")]
53          (m,1) => Matrix::DVector(new_ref(DVector::from_vec(elements))),
54          #[cfg(feature = "MatrixD")]
55          (m,n) => Matrix::DMatrix(new_ref(DMatrix::from_vec(m,n,elements))),
56        }}}};}
57
58impl ToMatrix for usize {
59  fn to_matrix(elements: Vec<Self>, rows: usize, cols: usize) -> Matrix<Self> {
60    match (rows,cols) {
61      (1,n) => Matrix::RowDVector(new_ref(RowDVector::from_vec(elements))),
62      (m,1) => Matrix::DVector(new_ref(DVector::from_vec(elements))),
63      (m,n) => Matrix::DMatrix(new_ref(DMatrix::from_vec(m,n,elements))),
64    }
65  }
66}
67
68impl_to_matrix!(Value);
69#[cfg(feature = "Bool")]
70impl_to_matrix!(bool);
71#[cfg(feature = "U8")]
72impl_to_matrix!(u8);
73#[cfg(feature = "U16")]
74impl_to_matrix!(u16);
75#[cfg(feature = "U32")]
76impl_to_matrix!(u32);
77#[cfg(feature = "U64")]
78impl_to_matrix!(u64);
79#[cfg(feature = "U128")]
80impl_to_matrix!(u128);
81#[cfg(feature = "I8")]
82impl_to_matrix!(i8);
83#[cfg(feature = "I16")]
84impl_to_matrix!(i16);
85#[cfg(feature = "I32")]
86impl_to_matrix!(i32);
87#[cfg(feature = "I64")]
88impl_to_matrix!(i64);
89#[cfg(feature = "I128")]
90impl_to_matrix!(i128);
91#[cfg(feature = "F32")]
92impl_to_matrix!(F32);
93#[cfg(feature = "F64")]
94impl_to_matrix!(F64);
95  
96pub trait ToIndex: Clone {
97  fn to_index(elements: Vec<Self>) -> Matrix<Self>;
98}
99
100#[derive(Clone, Debug, PartialEq, Eq)]
101pub enum Matrix<T> {
102  #[cfg(feature = "RowVector4")]
103  RowVector4(Ref<RowVector4<T>>),
104  #[cfg(feature = "RowVector3")]
105  RowVector3(Ref<RowVector3<T>>),
106  #[cfg(feature = "RowVector2")]
107  RowVector2(Ref<RowVector2<T>>),
108  #[cfg(feature = "RowVectorD")]
109  RowDVector(Ref<RowDVector<T>>),
110  #[cfg(feature = "Vector4")]
111  Vector4(Ref<Vector4<T>>),  
112  #[cfg(feature = "Vector3")]
113  Vector3(Ref<Vector3<T>>),
114  #[cfg(feature = "Vector2")]
115  Vector2(Ref<Vector2<T>>),
116  #[cfg(feature = "VectorD")]
117  DVector(Ref<DVector<T>>),
118  #[cfg(feature = "Matrix4")]
119  Matrix4(Ref<Matrix4<T>>),
120  #[cfg(feature = "Matrix3")]
121  Matrix3(Ref<Matrix3<T>>),
122  #[cfg(feature = "Matrix2")]
123  Matrix2(Ref<Matrix2<T>>),
124  #[cfg(feature = "Matrix1")]
125  Matrix1(Ref<Matrix1<T>>),
126  #[cfg(feature = "Matrix3x2")]
127  Matrix3x2(Ref<Matrix3x2<T>>),
128  #[cfg(feature = "Matrix2x3")]
129  Matrix2x3(Ref<Matrix2x3<T>>),
130  #[cfg(feature = "MatrixD")]
131  DMatrix(Ref<DMatrix<T>>),
132}
133
134impl<T> fmt::Display for Matrix<T>
135where T: Debug + Display + Clone + PartialEq + 'static {
136  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
137    std::fmt::Display::fmt(&self.pretty_print(), f)
138  }
139}
140
141pub trait CopyMat<T> {
142  fn copy_into(&self, dst: &Ref<DMatrix<T>>, offset: usize) -> usize;
143  fn copy_into_v(&self, dst: &Ref<DVector<T>>, offset: usize) -> usize;
144  fn copy_into_r(&self, dst: &Ref<RowDVector<T>>, offset: usize) -> usize;
145  fn copy_into_row_major(&self, dst: &Ref<DMatrix<T>>, offset: usize) -> usize;
146}
147
148macro_rules! copy_mat {
149  ($matsize:ident) => {
150    impl<T> CopyMat<T> for Ref<$matsize<T>> 
151    where T: Clone 
152    {
153      fn copy_into(&self, dst: &Ref<DMatrix<T>>, offset: usize) -> usize {
154        let src_ptr = unsafe { (*(self.as_ptr())).clone() };
155        let mut dst_ptr = unsafe { &mut *(dst.as_ptr()) };
156        for i in 0..src_ptr.len() {
157            dst_ptr[i + offset] = src_ptr[i].clone();
158        }
159        src_ptr.len()
160      }
161      fn copy_into_v(&self, dst: &Ref<DVector<T>>, offset: usize) -> usize {
162        let src_ptr = unsafe { (*(self.as_ptr())).clone() };
163        let mut dst_ptr = unsafe { &mut *(dst.as_ptr()) };
164        for i in 0..src_ptr.len() {
165            dst_ptr[i + offset] = src_ptr[i].clone();
166        }
167        src_ptr.len()
168      }
169      fn copy_into_r(&self, dst: &Ref<RowDVector<T>>, offset: usize) -> usize {
170        let src_ptr = unsafe { (*(self.as_ptr())).clone() };
171        let mut dst_ptr = unsafe { &mut *(dst.as_ptr()) };
172        for i in 0..src_ptr.len() {
173            dst_ptr[i + offset] = src_ptr[i].clone();
174        }
175        src_ptr.len()
176      }
177      fn copy_into_row_major(&self, dst: &Ref<DMatrix<T>>, offset: usize) -> usize {
178        let src_ptr = unsafe { (*(self.as_ptr())).clone() };
179        let mut dst_ptr = unsafe { &mut *(dst.as_ptr()) };
180        let src_rows = src_ptr.nrows();
181        let dest_rows = dst_ptr.nrows();
182
183        let stride = dest_rows - src_rows;
184        let mut offset = offset;
185        for ix in 0..src_ptr.len() {
186            dst_ptr[offset] = src_ptr[ix].clone();
187            offset += ((ix + 1) % src_rows == 0) as usize * stride + 1;
188        }
189        src_rows
190      }}};}
191      
192copy_mat!(DMatrix);
193copy_mat!(Matrix1);
194copy_mat!(Matrix2);
195copy_mat!(Matrix3);
196copy_mat!(Matrix4);
197copy_mat!(Matrix2x3);
198copy_mat!(Matrix3x2);
199copy_mat!(Vector2);
200copy_mat!(Vector3);
201copy_mat!(Vector4);
202copy_mat!(DVector);
203copy_mat!(RowVector2);
204copy_mat!(RowVector3);
205copy_mat!(RowVector4);
206copy_mat!(RowDVector);
207
208impl<T> Hash for Matrix<T> 
209where T: Hash + na::Scalar
210{
211  fn hash<H: Hasher>(&self, state: &mut H) {
212    match self {
213      #[cfg(feature = "RowVector4")]
214      Matrix::RowVector4(x) => x.borrow().hash(state),
215      #[cfg(feature = "RowVector3")]
216      Matrix::RowVector3(x) => x.borrow().hash(state),
217      #[cfg(feature = "RowVector2")]
218      Matrix::RowVector2(x) => x.borrow().hash(state),
219      #[cfg(feature = "RowVectorD")]
220      Matrix::RowDVector(x) => x.borrow().hash(state),
221      #[cfg(feature = "Vector4")]
222      Matrix::Vector4(x) => x.borrow().hash(state),
223      #[cfg(feature = "Vector3")]
224      Matrix::Vector3(x) => x.borrow().hash(state),
225      #[cfg(feature = "Vector2")]
226      Matrix::Vector2(x) => x.borrow().hash(state),
227      #[cfg(feature = "VectorD")]
228      Matrix::DVector(x) => x.borrow().hash(state),
229      #[cfg(feature = "Matrix4")]
230      Matrix::Matrix4(x) => x.borrow().hash(state),
231      #[cfg(feature = "Matrix3")]
232      Matrix::Matrix3(x) => x.borrow().hash(state),
233      #[cfg(feature = "Matrix2")]
234      Matrix::Matrix2(x) => x.borrow().hash(state),
235      #[cfg(feature = "Matrix1")]
236      Matrix::Matrix1(x) => x.borrow().hash(state),
237      #[cfg(feature = "Matrix3x2")]
238      Matrix::Matrix3x2(x) => x.borrow().hash(state),
239      #[cfg(feature = "Matrix2x3")]
240      Matrix::Matrix2x3(x) => x.borrow().hash(state),
241      #[cfg(feature = "MatrixD")]
242      Matrix::DMatrix(x) => x.borrow().hash(state),
243    }
244  }
245}
246
247impl<T> Matrix<T> 
248where T: Debug + Display + Clone + PartialEq + 'static
249{
250
251  pub fn size_of(&self) -> usize {
252    let vec = self.as_vec();
253    vec.capacity() * size_of::<T>()
254  }
255
256  pub fn get_copyable_matrix(&self) -> Box<dyn CopyMat<T>> {
257    match self {
258      #[cfg(feature = "RowVector4")]
259      Matrix::RowVector4(ref x) => Box::new(x.clone()),
260      #[cfg(feature = "RowVector3")]
261      Matrix::RowVector3(ref x) => Box::new(x.clone()),
262      #[cfg(feature = "RowVector2")]
263      Matrix::RowVector2(ref x) => Box::new(x.clone()),
264      #[cfg(feature = "RowVectorD")]
265      Matrix::RowDVector(ref x) => Box::new(x.clone()),
266      #[cfg(feature = "Vector4")]
267      Matrix::Vector4(ref x) => Box::new(x.clone()),
268      #[cfg(feature = "Vector3")]
269      Matrix::Vector3(ref x) => Box::new(x.clone()),
270      #[cfg(feature = "Vector2")]
271      Matrix::Vector2(ref x) => Box::new(x.clone()),
272      #[cfg(feature = "VectorD")]
273      Matrix::DVector(ref x) => Box::new(x.clone()),
274      #[cfg(feature = "Matrix4")]
275      Matrix::Matrix4(ref x) => Box::new(x.clone()),
276      #[cfg(feature = "Matrix3")]
277      Matrix::Matrix3(ref x) => Box::new(x.clone()),
278      #[cfg(feature = "Matrix2")]
279      Matrix::Matrix2(ref x) => Box::new(x.clone()),
280      #[cfg(feature = "Matrix1")]
281      Matrix::Matrix1(ref x) => Box::new(x.clone()),
282      #[cfg(feature = "Matrix3x2")]
283      Matrix::Matrix3x2(ref x) => Box::new(x.clone()),
284      #[cfg(feature = "Matrix2x3")]
285      Matrix::Matrix2x3(ref x) => Box::new(x.clone()),
286      #[cfg(feature = "MatrixD")]
287      Matrix::DMatrix(ref x) => Box::new(x.clone()),
288    }
289  }
290
291
292  pub fn pretty_print(&self) -> String {
293    let mut builder = Builder::default();
294    match self {
295      #[cfg(feature = "RowVector4")]
296      Matrix::RowVector4(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
297      #[cfg(feature = "RowVector3")]
298      Matrix::RowVector3(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
299      #[cfg(feature = "RowVector2")]
300      Matrix::RowVector2(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
301      #[cfg(feature = "RowVectorD")]
302      Matrix::RowDVector(vec) => {
303        let vec_brrw = vec.borrow();
304        let vec_str = if vec_brrw.ncols() > 20 {
305          let mut vec_str = vec_brrw.row(0).iter().take(10).chain(vec_brrw.row(0).iter().rev().take(9).rev()).map(|x| format!("{}", x)).collect::<Vec<_>>();
306          vec_str.insert(10,"...".to_string());
307          vec_str
308        } else {
309          vec_brrw.row(0).iter().map(|x| format!("{:?}", x)).collect::<Vec<_>>()
310        };
311        builder.push_record(vec_str);
312      }
313      #[cfg(feature = "Vector4")]
314      Matrix::Vector4(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
315      #[cfg(feature = "Vector3")]
316      Matrix::Vector3(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
317      #[cfg(feature = "Vector2")]
318      Matrix::Vector2(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
319      #[cfg(feature = "VectorD")]
320      Matrix::DVector(vec) => {
321        let vec_brrw = vec.borrow();
322        let vec_str = if vec_brrw.nrows() > 20 {
323          let mut vec_str = vec_brrw.column(0).iter().take(10).chain(vec_brrw.column(0).iter().rev().take(9).rev()).map(|x| format!("{}", x)).collect::<Vec<_>>();
324          vec_str.insert(10,"...".to_string());
325          vec_str
326        } else {
327          vec_brrw.column(0).iter().map(|x| format!("{:?}", x)).collect::<Vec<_>>()
328        };
329        for r in vec_str {
330          builder.push_record(vec![r]);
331        }
332      }
333      #[cfg(feature = "Matrix4")]
334      Matrix::Matrix4(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
335      #[cfg(feature = "Matrix3")]
336      Matrix::Matrix3(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
337      #[cfg(feature = "Matrix2")]
338      Matrix::Matrix2(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
339      #[cfg(feature = "Matrix1")]
340      Matrix::Matrix1(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
341      #[cfg(feature = "Matrix3x2")]
342      Matrix::Matrix3x2(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
343      #[cfg(feature = "Matrix2x3")]
344      Matrix::Matrix2x3(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
345      #[cfg(feature = "MatrixD")]
346      Matrix::DMatrix(vec) => {let vec_brrw = vec.borrow();(0..vec_brrw.nrows()).for_each(|i| builder.push_record(vec_brrw.row(i).iter().map(|x| format!("{}", x)).collect::<Vec<_>>()));}
347      _ => todo!(),
348    };
349    let matrix_style = Style::empty()
350    .top(' ')
351    .left('┃')
352    .right('┃')
353    .bottom(' ')
354    .vertical(' ')
355    .intersection_bottom(' ')
356    .corner_top_left('┏')
357    .corner_top_right('┓')
358    .corner_bottom_left('┗')
359    .corner_bottom_right('┛');
360    let mut table = builder.build();
361    table.with(matrix_style);
362    format!("{table}")
363  }
364
365  pub fn shape(&self) -> Vec<usize> {
366    let shape = match self {
367      #[cfg(feature = "RowVector4")]
368      Matrix::RowVector4(x) => x.borrow().shape(),
369      #[cfg(feature = "RowVector3")]
370      Matrix::RowVector3(x) => x.borrow().shape(),
371      #[cfg(feature = "RowVector2")]
372      Matrix::RowVector2(x) => x.borrow().shape(),
373      #[cfg(feature = "RowVectorD")]
374      Matrix::RowDVector(x) => x.borrow().shape(),
375      #[cfg(feature = "Vector4")]
376      Matrix::Vector4(x) => x.borrow().shape(),
377      #[cfg(feature = "Vector3")]
378      Matrix::Vector3(x) => x.borrow().shape(),
379      #[cfg(feature = "Vector2")]
380      Matrix::Vector2(x) => x.borrow().shape(),
381      #[cfg(feature = "VectorD")]
382      Matrix::DVector(x) => x.borrow().shape(),
383      #[cfg(feature = "Matrix4")]
384      Matrix::Matrix4(x) => x.borrow().shape(),
385      #[cfg(feature = "Matrix3")]
386      Matrix::Matrix3(x) => x.borrow().shape(),
387      #[cfg(feature = "Matrix2")]
388      Matrix::Matrix2(x) => x.borrow().shape(),
389      #[cfg(feature = "Matrix1")]
390      Matrix::Matrix1(x) => x.borrow().shape(),
391      #[cfg(feature = "Matrix3x2")]
392      Matrix::Matrix3x2(x) => x.borrow().shape(),
393      #[cfg(feature = "Matrix2x3")]
394      Matrix::Matrix2x3(x) => x.borrow().shape(),
395      #[cfg(feature = "MatrixD")]
396      Matrix::DMatrix(x) => x.borrow().shape(),
397    };
398    vec![shape.0, shape.1]
399  }
400
401  pub fn index1d(&self, ix: usize) -> T {
402    match self {
403      #[cfg(feature = "RowVector4")]
404      Matrix::RowVector4(x) => (*x.borrow().index(ix-1)).clone(),
405      #[cfg(feature = "RowVector3")]
406      Matrix::RowVector3(x) => (*x.borrow().index(ix-1)).clone(),
407      #[cfg(feature = "RowVector2")]
408      Matrix::RowVector2(x) => (*x.borrow().index(ix-1)).clone(),
409      #[cfg(feature = "RowVectorD")]
410      Matrix::RowDVector(x) => (*x.borrow().index(ix-1)).clone(),
411      #[cfg(feature = "Vector4")]
412      Matrix::Vector4(x) => (*x.borrow().index(ix-1)).clone(),
413      #[cfg(feature = "Vector3")]
414      Matrix::Vector3(x) => (*x.borrow().index(ix-1)).clone(),
415      #[cfg(feature = "Vector2")]
416      Matrix::Vector2(x) => (*x.borrow().index(ix-1)).clone(),
417      #[cfg(feature = "VectorD")]
418      Matrix::DVector(x) => (*x.borrow().index(ix-1)).clone(),
419      #[cfg(feature = "Matrix4")]
420      Matrix::Matrix4(x) => (*x.borrow().index(ix-1)).clone(),
421      #[cfg(feature = "Matrix3")]
422      Matrix::Matrix3(x) => (*x.borrow().index(ix-1)).clone(),
423      #[cfg(feature = "Matrix2")]
424      Matrix::Matrix2(x) => (*x.borrow().index(ix-1)).clone(),
425      #[cfg(feature = "Matrix1")]
426      Matrix::Matrix1(x) => (*x.borrow().index(ix-1)).clone(),
427      #[cfg(feature = "Matrix3x2")]
428      Matrix::Matrix3x2(x) => (*x.borrow().index(ix-1)).clone(),
429      #[cfg(feature = "Matrix2x3")]
430      Matrix::Matrix2x3(x) => (*x.borrow().index(ix-1)).clone(),
431      #[cfg(feature = "MatrixD")]
432      Matrix::DMatrix(x) => (*x.borrow().index(ix-1)).clone(),
433    }
434  }
435
436  pub fn set(&self, elements: Vec<T>) {
437    match self {
438      #[cfg(feature = "RowVector4")]
439      Matrix::RowVector4(x) => {
440        let mut x = x.borrow_mut();
441        x[0] = elements[0].clone();
442        x[1] = elements[1].clone();
443        x[2] = elements[2].clone();
444        x[3] = elements[3].clone();
445      }
446      #[cfg(feature = "RowVector3")]
447      Matrix::RowVector3(x) => {
448        let mut x = x.borrow_mut();
449        x[0] = elements[0].clone();
450        x[1] = elements[1].clone();
451        x[2] = elements[2].clone();
452      }
453      #[cfg(feature = "RowVector2")]
454      Matrix::RowVector2(x) => {
455        let mut x = x.borrow_mut();
456        x[0] = elements[0].clone();
457        x[1] = elements[1].clone();
458      }
459      #[cfg(feature = "RowVectorD")]
460      Matrix::RowDVector(x) => {let mut x = x.borrow_mut();for i in 0..elements.len() {x[i] = elements[i].clone();}},
461      #[cfg(feature = "Vector4")]
462      Matrix::Vector4(x) => {
463        let mut x = x.borrow_mut();
464        x[0] = elements[0].clone();
465        x[1] = elements[1].clone();
466        x[2] = elements[2].clone();
467        x[3] = elements[3].clone();
468      }
469      #[cfg(feature = "Vector3")]
470      Matrix::Vector3(x) => {
471        let mut x = x.borrow_mut();
472        x[0] = elements[0].clone();
473        x[1] = elements[1].clone();
474        x[2] = elements[2].clone();
475      }
476      #[cfg(feature = "Vector2")]
477      Matrix::Vector2(x) => {
478        let mut x = x.borrow_mut();
479        x[0] = elements[0].clone();
480        x[1] = elements[1].clone();
481      }
482      #[cfg(feature = "VectorD")]
483      Matrix::DVector(x) => {let mut x = x.borrow_mut();for i in 0..elements.len() {x[i] = elements[i].clone();}},
484      #[cfg(feature = "Matrix4")]
485      Matrix::Matrix4(x) => {
486        let mut x = x.borrow_mut();
487        x[0] = elements[0].clone();
488        x[1] = elements[1].clone();
489        x[2] = elements[2].clone();
490        x[3] = elements[3].clone();
491        x[4] = elements[4].clone();
492        x[5] = elements[5].clone();
493        x[6] = elements[6].clone();
494        x[7] = elements[7].clone();
495        x[8] = elements[8].clone();
496        x[9] = elements[9].clone();
497        x[10] = elements[10].clone();
498        x[11] = elements[11].clone();
499        x[12] = elements[12].clone();
500        x[13] = elements[13].clone();
501        x[14] = elements[14].clone();
502        x[15] = elements[15].clone();
503      }
504      #[cfg(feature = "Matrix3")]
505      Matrix::Matrix3(x) => {
506        let mut x = x.borrow_mut();
507        x[0] = elements[0].clone();
508        x[1] = elements[1].clone();
509        x[2] = elements[2].clone();
510        x[3] = elements[3].clone();
511        x[4] = elements[4].clone();
512        x[5] = elements[5].clone();
513        x[6] = elements[6].clone();
514        x[7] = elements[7].clone();
515        x[8] = elements[8].clone();
516      }
517      #[cfg(feature = "Matrix2")]
518      Matrix::Matrix2(x) => {
519        let mut x = x.borrow_mut();
520        x[0] = elements[0].clone();
521        x[1] = elements[1].clone();
522        x[2] = elements[2].clone();
523        x[3] = elements[3].clone();
524      }
525      #[cfg(feature = "Matrix1")]
526      Matrix::Matrix1(x) => {let mut x = x.borrow_mut();x[0] = elements[0].clone();},
527      #[cfg(feature = "Matrix3x2")]
528      Matrix::Matrix3x2(x) => {
529        let mut x = x.borrow_mut();
530        x[0] = elements[0].clone();
531        x[1] = elements[1].clone();
532        x[2] = elements[2].clone();
533        x[3] = elements[3].clone();
534        x[4] = elements[4].clone();
535        x[5] = elements[5].clone();
536      }
537      #[cfg(feature = "Matrix2x3")]
538      Matrix::Matrix2x3(x) => {
539        let mut x = x.borrow_mut();
540        x[0] = elements[0].clone();
541        x[1] = elements[1].clone();
542        x[2] = elements[2].clone();
543        x[3] = elements[3].clone();
544        x[4] = elements[4].clone();
545        x[5] = elements[5].clone();
546      }
547      #[cfg(feature = "MatrixD")]
548      Matrix::DMatrix(x) => {let mut x = x.borrow_mut();for i in 0..elements.len() {x[i] = elements[i].clone();}},
549    }
550  }
551
552  pub fn index2d(&self, row: usize, col: usize) -> T {
553    match self {
554      #[cfg(feature = "RowVector4")]
555      Matrix::RowVector4(x) => (*x.borrow().index((row-1,col-1))).clone(),
556      #[cfg(feature = "RowVector3")]
557      Matrix::RowVector3(x) => (*x.borrow().index((row-1,col-1))).clone(),
558      #[cfg(feature = "RowVector2")]
559      Matrix::RowVector2(x) => (*x.borrow().index((row-1,col-1))).clone(),
560      #[cfg(feature = "RowVectorD")]
561      Matrix::RowDVector(x) => (*x.borrow().index((row-1,col-1))).clone(),
562      #[cfg(feature = "Vector4")]
563      Matrix::Vector4(x) => (*x.borrow().index((row-1,col-1))).clone(),
564      #[cfg(feature = "Vector3")]
565      Matrix::Vector3(x) => (*x.borrow().index((row-1,col-1))).clone(),
566      #[cfg(feature = "Vector2")]
567      Matrix::Vector2(x) => (*x.borrow().index((row-1,col-1))).clone(),
568      #[cfg(feature = "VectorD")]
569      Matrix::DVector(x) => (*x.borrow().index((row-1,col-1))).clone(),
570      #[cfg(feature = "Matrix4")]
571      Matrix::Matrix4(x) => (*x.borrow().index((row-1,col-1))).clone(),
572      #[cfg(feature = "Matrix3")]
573      Matrix::Matrix3(x) => (*x.borrow().index((row-1,col-1))).clone(),
574      #[cfg(feature = "Matrix2")]
575      Matrix::Matrix2(x) => (*x.borrow().index((row-1,col-1))).clone(),
576      #[cfg(feature = "Matrix1")]
577      Matrix::Matrix1(x) => (*x.borrow().index((row-1,col-1))).clone(),
578      #[cfg(feature = "Matrix3x2")]
579      Matrix::Matrix3x2(x) => (*x.borrow().index((row-1,col-1))).clone(),
580      #[cfg(feature = "Matrix2x3")]
581      Matrix::Matrix2x3(x) => (*x.borrow().index((row-1,col-1))).clone(),
582      #[cfg(feature = "MatrixD")]
583      Matrix::DMatrix(x) => (*x.borrow().index((row-1,col-1))).clone(),
584    }
585  }
586
587  pub fn as_vec(&self) -> Vec<T> {
588    match self {
589      #[cfg(feature = "RowVector4")]
590      Matrix::RowVector4(x) => x.borrow().as_slice().to_vec(),
591      #[cfg(feature = "RowVector3")]
592      Matrix::RowVector3(x) => x.borrow().as_slice().to_vec(),
593      #[cfg(feature = "RowVector2")]
594      Matrix::RowVector2(x) => x.borrow().as_slice().to_vec(),
595      #[cfg(feature = "RowVectorD")]
596      Matrix::RowDVector(x) => x.borrow().as_slice().to_vec(),
597      #[cfg(feature = "Vector4")]
598      Matrix::Vector4(x) => x.borrow().as_slice().to_vec(),
599      #[cfg(feature = "Vector3")]
600      Matrix::Vector3(x) => x.borrow().as_slice().to_vec(),
601      #[cfg(feature = "Vector2")]
602      Matrix::Vector2(x) => x.borrow().as_slice().to_vec(),
603      #[cfg(feature = "VectorD")]
604      Matrix::DVector(x) => x.borrow().as_slice().to_vec(),
605      #[cfg(feature = "Matrix4")]
606      Matrix::Matrix4(x) => x.borrow().as_slice().to_vec(),
607      #[cfg(feature = "Matrix3")]
608      Matrix::Matrix3(x) => x.borrow().as_slice().to_vec(),
609      #[cfg(feature = "Matrix2")]
610      Matrix::Matrix2(x) => x.borrow().as_slice().to_vec(),
611      #[cfg(feature = "Matrix1")]
612      Matrix::Matrix1(x) => x.borrow().as_slice().to_vec(),
613      #[cfg(feature = "Matrix3x2")]
614      Matrix::Matrix3x2(x) => x.borrow().as_slice().to_vec(),
615      #[cfg(feature = "Matrix2x3")]
616      Matrix::Matrix2x3(x) => x.borrow().as_slice().to_vec(),
617      #[cfg(feature = "MatrixD")]
618      Matrix::DMatrix(x) => x.borrow().as_slice().to_vec(),
619    }
620  }
621
622}
623
624
625impl ToValue for Matrix<Value> {
626
627  fn to_value(&self) -> Value {
628    Value::MatrixValue(self.clone())
629  }
630  
631}
mech_core/matrix.rs

mech_core/
matrix.rs
