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
134pub trait CopyMat<T> {
135  fn copy_into(&self, dst: &Ref<DMatrix<T>>, offset: usize) -> usize;
136  fn copy_into_v(&self, dst: &Ref<DVector<T>>, offset: usize) -> usize;
137  fn copy_into_r(&self, dst: &Ref<RowDVector<T>>, offset: usize) -> usize;
138  fn copy_into_row_major(&self, dst: &Ref<DMatrix<T>>, offset: usize) -> usize;
139}
140
141macro_rules! copy_mat {
142  ($matsize:ident) => {
143    impl<T> CopyMat<T> for Ref<$matsize<T>> 
144    where T: Clone 
145    {
146      fn copy_into(&self, dst: &Ref<DMatrix<T>>, offset: usize) -> usize {
147        let src_ptr = unsafe { (*(self.as_ptr())).clone() };
148        let mut dst_ptr = unsafe { &mut *(dst.as_ptr()) };
149        for i in 0..src_ptr.len() {
150            dst_ptr[i + offset] = src_ptr[i].clone();
151        }
152        src_ptr.len()
153      }
154      fn copy_into_v(&self, dst: &Ref<DVector<T>>, offset: usize) -> usize {
155        let src_ptr = unsafe { (*(self.as_ptr())).clone() };
156        let mut dst_ptr = unsafe { &mut *(dst.as_ptr()) };
157        for i in 0..src_ptr.len() {
158            dst_ptr[i + offset] = src_ptr[i].clone();
159        }
160        src_ptr.len()
161      }
162      fn copy_into_r(&self, dst: &Ref<RowDVector<T>>, offset: usize) -> usize {
163        let src_ptr = unsafe { (*(self.as_ptr())).clone() };
164        let mut dst_ptr = unsafe { &mut *(dst.as_ptr()) };
165        for i in 0..src_ptr.len() {
166            dst_ptr[i + offset] = src_ptr[i].clone();
167        }
168        src_ptr.len()
169      }
170      fn copy_into_row_major(&self, dst: &Ref<DMatrix<T>>, offset: usize) -> usize {
171        let src_ptr = unsafe { (*(self.as_ptr())).clone() };
172        let mut dst_ptr = unsafe { &mut *(dst.as_ptr()) };
173        let src_rows = src_ptr.nrows();
174        let dest_rows = dst_ptr.nrows();
175
176        let stride = dest_rows - src_rows;
177        let mut offset = offset;
178        for ix in 0..src_ptr.len() {
179            dst_ptr[offset] = src_ptr[ix].clone();
180            offset += ((ix + 1) % src_rows == 0) as usize * stride + 1;
181        }
182        src_rows
183      }}};}
184      
185copy_mat!(DMatrix);
186copy_mat!(Matrix1);
187copy_mat!(Matrix2);
188copy_mat!(Matrix3);
189copy_mat!(Matrix4);
190copy_mat!(Matrix2x3);
191copy_mat!(Matrix3x2);
192copy_mat!(Vector2);
193copy_mat!(Vector3);
194copy_mat!(Vector4);
195copy_mat!(DVector);
196copy_mat!(RowVector2);
197copy_mat!(RowVector3);
198copy_mat!(RowVector4);
199copy_mat!(RowDVector);
200
201impl<T> Hash for Matrix<T> 
202where T: Hash + na::Scalar
203{
204  fn hash<H: Hasher>(&self, state: &mut H) {
205    match self {
206      #[cfg(feature = "RowVector4")]
207      Matrix::RowVector4(x) => x.borrow().hash(state),
208      #[cfg(feature = "RowVector3")]
209      Matrix::RowVector3(x) => x.borrow().hash(state),
210      #[cfg(feature = "RowVector2")]
211      Matrix::RowVector2(x) => x.borrow().hash(state),
212      #[cfg(feature = "RowVectorD")]
213      Matrix::RowDVector(x) => x.borrow().hash(state),
214      #[cfg(feature = "Vector4")]
215      Matrix::Vector4(x) => x.borrow().hash(state),
216      #[cfg(feature = "Vector3")]
217      Matrix::Vector3(x) => x.borrow().hash(state),
218      #[cfg(feature = "Vector2")]
219      Matrix::Vector2(x) => x.borrow().hash(state),
220      #[cfg(feature = "VectorD")]
221      Matrix::DVector(x) => x.borrow().hash(state),
222      #[cfg(feature = "Matrix4")]
223      Matrix::Matrix4(x) => x.borrow().hash(state),
224      #[cfg(feature = "Matrix3")]
225      Matrix::Matrix3(x) => x.borrow().hash(state),
226      #[cfg(feature = "Matrix2")]
227      Matrix::Matrix2(x) => x.borrow().hash(state),
228      #[cfg(feature = "Matrix1")]
229      Matrix::Matrix1(x) => x.borrow().hash(state),
230      #[cfg(feature = "Matrix3x2")]
231      Matrix::Matrix3x2(x) => x.borrow().hash(state),
232      #[cfg(feature = "Matrix2x3")]
233      Matrix::Matrix2x3(x) => x.borrow().hash(state),
234      #[cfg(feature = "MatrixD")]
235      Matrix::DMatrix(x) => x.borrow().hash(state),
236    }
237  }
238}
239
240
241pub trait PrettyPrint {
242  fn pretty_print(&self) -> String;
243}
244
245impl PrettyPrint for String {
246  fn pretty_print(&self) -> String {
247      format!("\"{}\"", self)
248  }
249}
250
251impl PrettyPrint for Value {
252  fn  pretty_print(&self) -> String {
253    self.pretty_print()
254  }
255}
256
257macro_rules! impl_pretty_print {
258  ($t:ty) => {
259    impl PrettyPrint for $t {
260      fn pretty_print(&self) -> String {
261        format!("{}", self)
262      }
263    }
264  };
265}
266
267impl_pretty_print!(bool);
268impl_pretty_print!(i8);
269impl_pretty_print!(i16);
270impl_pretty_print!(i32);
271impl_pretty_print!(i64);
272impl_pretty_print!(i128);
273impl_pretty_print!(u8);
274impl_pretty_print!(u16);
275impl_pretty_print!(u32);
276impl_pretty_print!(u64);
277impl_pretty_print!(u128);
278impl_pretty_print!(F32);
279impl_pretty_print!(F64);
280impl_pretty_print!(usize);
281
282impl<T> PrettyPrint for Matrix<T>
283where T: Debug + Display + Clone + PartialEq + 'static + PrettyPrint
284{
285  fn pretty_print(&self) -> String {
286    let mut builder = Builder::default();
287    match self {
288      #[cfg(feature = "RowVector4")]
289      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| x.pretty_print()).collect::<Vec<_>>()));}
290      #[cfg(feature = "RowVector3")]
291      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| x.pretty_print()).collect::<Vec<_>>()));}
292      #[cfg(feature = "RowVector2")]
293      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| x.pretty_print()).collect::<Vec<_>>()));}
294      #[cfg(feature = "RowVectorD")]
295      Matrix::RowDVector(vec) => {
296        let vec_brrw = vec.borrow();
297        let vec_str = if vec_brrw.ncols() > 20 {
298          let mut vec_str = vec_brrw.row(0).iter().take(10).chain(vec_brrw.row(0).iter().rev().take(9).rev()).map(|x| x.pretty_print()).collect::<Vec<_>>();
299          vec_str.insert(10,"...".to_string());
300          vec_str
301        } else {
302          vec_brrw.row(0).iter().map(|x| format!("{:?}", x)).collect::<Vec<_>>()
303        };
304        builder.push_record(vec_str);
305      }
306      #[cfg(feature = "Vector4")]
307      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| x.pretty_print()).collect::<Vec<_>>()));}
308      #[cfg(feature = "Vector3")]
309      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| x.pretty_print()).collect::<Vec<_>>()));}
310      #[cfg(feature = "Vector2")]
311      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| x.pretty_print()).collect::<Vec<_>>()));}
312      #[cfg(feature = "VectorD")]
313      Matrix::DVector(vec) => {
314        let vec_brrw = vec.borrow();
315        let vec_str = if vec_brrw.nrows() > 20 {
316          let mut vec_str = vec_brrw.column(0).iter().take(10).chain(vec_brrw.column(0).iter().rev().take(9).rev()).map(|x| x.pretty_print()).collect::<Vec<_>>();
317          vec_str.insert(10,"...".to_string());
318          vec_str
319        } else {
320          vec_brrw.column(0).iter().map(|x| x.pretty_print()).collect::<Vec<_>>()
321        };
322        for r in vec_str {
323          builder.push_record(vec![r]);
324        }
325      }
326      #[cfg(feature = "Matrix4")]
327      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| x.pretty_print()).collect::<Vec<_>>()));}
328      #[cfg(feature = "Matrix3")]
329      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| x.pretty_print()).collect::<Vec<_>>()));}
330      #[cfg(feature = "Matrix2")]
331      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| x.pretty_print()).collect::<Vec<_>>()));}
332      #[cfg(feature = "Matrix1")]
333      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| x.pretty_print()).collect::<Vec<_>>()));}
334      #[cfg(feature = "Matrix3x2")]
335      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| x.pretty_print()).collect::<Vec<_>>()));}
336      #[cfg(feature = "Matrix2x3")]
337      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| x.pretty_print()).collect::<Vec<_>>()));}
338      #[cfg(feature = "MatrixD")]
339      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| x.pretty_print()).collect::<Vec<_>>()));}
340      _ => todo!(),
341    };
342    let matrix_style = Style::empty()
343    .top(' ')
344    .left('┃')
345    .right('┃')
346    .bottom(' ')
347    .vertical(' ')
348    .intersection_bottom(' ')
349    .corner_top_left('┏')
350    .corner_top_right('┓')
351    .corner_bottom_left('┗')
352    .corner_bottom_right('┛');
353    let mut table = builder.build();
354    table.with(matrix_style);
355    format!("{table}")
356  }
357}
358
359impl<T> Matrix<T> 
360where T: Debug + Display + Clone + PartialEq + 'static + PrettyPrint
361{
362
363  pub fn size_of(&self) -> usize {
364    let vec = self.as_vec();
365    vec.capacity() * size_of::<T>()
366  }
367
368  pub fn get_copyable_matrix(&self) -> Box<dyn CopyMat<T>> {
369    match self {
370      #[cfg(feature = "RowVector4")]
371      Matrix::RowVector4(ref x) => Box::new(x.clone()),
372      #[cfg(feature = "RowVector3")]
373      Matrix::RowVector3(ref x) => Box::new(x.clone()),
374      #[cfg(feature = "RowVector2")]
375      Matrix::RowVector2(ref x) => Box::new(x.clone()),
376      #[cfg(feature = "RowVectorD")]
377      Matrix::RowDVector(ref x) => Box::new(x.clone()),
378      #[cfg(feature = "Vector4")]
379      Matrix::Vector4(ref x) => Box::new(x.clone()),
380      #[cfg(feature = "Vector3")]
381      Matrix::Vector3(ref x) => Box::new(x.clone()),
382      #[cfg(feature = "Vector2")]
383      Matrix::Vector2(ref x) => Box::new(x.clone()),
384      #[cfg(feature = "VectorD")]
385      Matrix::DVector(ref x) => Box::new(x.clone()),
386      #[cfg(feature = "Matrix4")]
387      Matrix::Matrix4(ref x) => Box::new(x.clone()),
388      #[cfg(feature = "Matrix3")]
389      Matrix::Matrix3(ref x) => Box::new(x.clone()),
390      #[cfg(feature = "Matrix2")]
391      Matrix::Matrix2(ref x) => Box::new(x.clone()),
392      #[cfg(feature = "Matrix1")]
393      Matrix::Matrix1(ref x) => Box::new(x.clone()),
394      #[cfg(feature = "Matrix3x2")]
395      Matrix::Matrix3x2(ref x) => Box::new(x.clone()),
396      #[cfg(feature = "Matrix2x3")]
397      Matrix::Matrix2x3(ref x) => Box::new(x.clone()),
398      #[cfg(feature = "MatrixD")]
399      Matrix::DMatrix(ref x) => Box::new(x.clone()),
400    }
401  }
402
403  pub fn shape(&self) -> Vec<usize> {
404    let shape = match self {
405      #[cfg(feature = "RowVector4")]
406      Matrix::RowVector4(x) => x.borrow().shape(),
407      #[cfg(feature = "RowVector3")]
408      Matrix::RowVector3(x) => x.borrow().shape(),
409      #[cfg(feature = "RowVector2")]
410      Matrix::RowVector2(x) => x.borrow().shape(),
411      #[cfg(feature = "RowVectorD")]
412      Matrix::RowDVector(x) => x.borrow().shape(),
413      #[cfg(feature = "Vector4")]
414      Matrix::Vector4(x) => x.borrow().shape(),
415      #[cfg(feature = "Vector3")]
416      Matrix::Vector3(x) => x.borrow().shape(),
417      #[cfg(feature = "Vector2")]
418      Matrix::Vector2(x) => x.borrow().shape(),
419      #[cfg(feature = "VectorD")]
420      Matrix::DVector(x) => x.borrow().shape(),
421      #[cfg(feature = "Matrix4")]
422      Matrix::Matrix4(x) => x.borrow().shape(),
423      #[cfg(feature = "Matrix3")]
424      Matrix::Matrix3(x) => x.borrow().shape(),
425      #[cfg(feature = "Matrix2")]
426      Matrix::Matrix2(x) => x.borrow().shape(),
427      #[cfg(feature = "Matrix1")]
428      Matrix::Matrix1(x) => x.borrow().shape(),
429      #[cfg(feature = "Matrix3x2")]
430      Matrix::Matrix3x2(x) => x.borrow().shape(),
431      #[cfg(feature = "Matrix2x3")]
432      Matrix::Matrix2x3(x) => x.borrow().shape(),
433      #[cfg(feature = "MatrixD")]
434      Matrix::DMatrix(x) => x.borrow().shape(),
435    };
436    vec![shape.0, shape.1]
437  }
438
439  pub fn index1d(&self, ix: usize) -> T {
440    match self {
441      #[cfg(feature = "RowVector4")]
442      Matrix::RowVector4(x) => (*x.borrow().index(ix-1)).clone(),
443      #[cfg(feature = "RowVector3")]
444      Matrix::RowVector3(x) => (*x.borrow().index(ix-1)).clone(),
445      #[cfg(feature = "RowVector2")]
446      Matrix::RowVector2(x) => (*x.borrow().index(ix-1)).clone(),
447      #[cfg(feature = "RowVectorD")]
448      Matrix::RowDVector(x) => (*x.borrow().index(ix-1)).clone(),
449      #[cfg(feature = "Vector4")]
450      Matrix::Vector4(x) => (*x.borrow().index(ix-1)).clone(),
451      #[cfg(feature = "Vector3")]
452      Matrix::Vector3(x) => (*x.borrow().index(ix-1)).clone(),
453      #[cfg(feature = "Vector2")]
454      Matrix::Vector2(x) => (*x.borrow().index(ix-1)).clone(),
455      #[cfg(feature = "VectorD")]
456      Matrix::DVector(x) => (*x.borrow().index(ix-1)).clone(),
457      #[cfg(feature = "Matrix4")]
458      Matrix::Matrix4(x) => (*x.borrow().index(ix-1)).clone(),
459      #[cfg(feature = "Matrix3")]
460      Matrix::Matrix3(x) => (*x.borrow().index(ix-1)).clone(),
461      #[cfg(feature = "Matrix2")]
462      Matrix::Matrix2(x) => (*x.borrow().index(ix-1)).clone(),
463      #[cfg(feature = "Matrix1")]
464      Matrix::Matrix1(x) => (*x.borrow().index(ix-1)).clone(),
465      #[cfg(feature = "Matrix3x2")]
466      Matrix::Matrix3x2(x) => (*x.borrow().index(ix-1)).clone(),
467      #[cfg(feature = "Matrix2x3")]
468      Matrix::Matrix2x3(x) => (*x.borrow().index(ix-1)).clone(),
469      #[cfg(feature = "MatrixD")]
470      Matrix::DMatrix(x) => (*x.borrow().index(ix-1)).clone(),
471    }
472  }
473
474  pub fn set(&self, elements: Vec<T>) {
475    match self {
476      #[cfg(feature = "RowVector4")]
477      Matrix::RowVector4(x) => {
478        let mut x = x.borrow_mut();
479        x[0] = elements[0].clone();
480        x[1] = elements[1].clone();
481        x[2] = elements[2].clone();
482        x[3] = elements[3].clone();
483      }
484      #[cfg(feature = "RowVector3")]
485      Matrix::RowVector3(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      }
491      #[cfg(feature = "RowVector2")]
492      Matrix::RowVector2(x) => {
493        let mut x = x.borrow_mut();
494        x[0] = elements[0].clone();
495        x[1] = elements[1].clone();
496      }
497      #[cfg(feature = "RowVectorD")]
498      Matrix::RowDVector(x) => {let mut x = x.borrow_mut();for i in 0..elements.len() {x[i] = elements[i].clone();}},
499      #[cfg(feature = "Vector4")]
500      Matrix::Vector4(x) => {
501        let mut x = x.borrow_mut();
502        x[0] = elements[0].clone();
503        x[1] = elements[1].clone();
504        x[2] = elements[2].clone();
505        x[3] = elements[3].clone();
506      }
507      #[cfg(feature = "Vector3")]
508      Matrix::Vector3(x) => {
509        let mut x = x.borrow_mut();
510        x[0] = elements[0].clone();
511        x[1] = elements[1].clone();
512        x[2] = elements[2].clone();
513      }
514      #[cfg(feature = "Vector2")]
515      Matrix::Vector2(x) => {
516        let mut x = x.borrow_mut();
517        x[0] = elements[0].clone();
518        x[1] = elements[1].clone();
519      }
520      #[cfg(feature = "VectorD")]
521      Matrix::DVector(x) => {let mut x = x.borrow_mut();for i in 0..elements.len() {x[i] = elements[i].clone();}},
522      #[cfg(feature = "Matrix4")]
523      Matrix::Matrix4(x) => {
524        let mut x = x.borrow_mut();
525        x[0] = elements[0].clone();
526        x[1] = elements[1].clone();
527        x[2] = elements[2].clone();
528        x[3] = elements[3].clone();
529        x[4] = elements[4].clone();
530        x[5] = elements[5].clone();
531        x[6] = elements[6].clone();
532        x[7] = elements[7].clone();
533        x[8] = elements[8].clone();
534        x[9] = elements[9].clone();
535        x[10] = elements[10].clone();
536        x[11] = elements[11].clone();
537        x[12] = elements[12].clone();
538        x[13] = elements[13].clone();
539        x[14] = elements[14].clone();
540        x[15] = elements[15].clone();
541      }
542      #[cfg(feature = "Matrix3")]
543      Matrix::Matrix3(x) => {
544        let mut x = x.borrow_mut();
545        x[0] = elements[0].clone();
546        x[1] = elements[1].clone();
547        x[2] = elements[2].clone();
548        x[3] = elements[3].clone();
549        x[4] = elements[4].clone();
550        x[5] = elements[5].clone();
551        x[6] = elements[6].clone();
552        x[7] = elements[7].clone();
553        x[8] = elements[8].clone();
554      }
555      #[cfg(feature = "Matrix2")]
556      Matrix::Matrix2(x) => {
557        let mut x = x.borrow_mut();
558        x[0] = elements[0].clone();
559        x[1] = elements[1].clone();
560        x[2] = elements[2].clone();
561        x[3] = elements[3].clone();
562      }
563      #[cfg(feature = "Matrix1")]
564      Matrix::Matrix1(x) => {let mut x = x.borrow_mut();x[0] = elements[0].clone();},
565      #[cfg(feature = "Matrix3x2")]
566      Matrix::Matrix3x2(x) => {
567        let mut x = x.borrow_mut();
568        x[0] = elements[0].clone();
569        x[1] = elements[1].clone();
570        x[2] = elements[2].clone();
571        x[3] = elements[3].clone();
572        x[4] = elements[4].clone();
573        x[5] = elements[5].clone();
574      }
575      #[cfg(feature = "Matrix2x3")]
576      Matrix::Matrix2x3(x) => {
577        let mut x = x.borrow_mut();
578        x[0] = elements[0].clone();
579        x[1] = elements[1].clone();
580        x[2] = elements[2].clone();
581        x[3] = elements[3].clone();
582        x[4] = elements[4].clone();
583        x[5] = elements[5].clone();
584      }
585      #[cfg(feature = "MatrixD")]
586      Matrix::DMatrix(x) => {let mut x = x.borrow_mut();for i in 0..elements.len() {x[i] = elements[i].clone();}},
587    }
588  }
589
590  pub fn index2d(&self, row: usize, col: usize) -> T {
591    match self {
592      #[cfg(feature = "RowVector4")]
593      Matrix::RowVector4(x) => (*x.borrow().index((row-1,col-1))).clone(),
594      #[cfg(feature = "RowVector3")]
595      Matrix::RowVector3(x) => (*x.borrow().index((row-1,col-1))).clone(),
596      #[cfg(feature = "RowVector2")]
597      Matrix::RowVector2(x) => (*x.borrow().index((row-1,col-1))).clone(),
598      #[cfg(feature = "RowVectorD")]
599      Matrix::RowDVector(x) => (*x.borrow().index((row-1,col-1))).clone(),
600      #[cfg(feature = "Vector4")]
601      Matrix::Vector4(x) => (*x.borrow().index((row-1,col-1))).clone(),
602      #[cfg(feature = "Vector3")]
603      Matrix::Vector3(x) => (*x.borrow().index((row-1,col-1))).clone(),
604      #[cfg(feature = "Vector2")]
605      Matrix::Vector2(x) => (*x.borrow().index((row-1,col-1))).clone(),
606      #[cfg(feature = "VectorD")]
607      Matrix::DVector(x) => (*x.borrow().index((row-1,col-1))).clone(),
608      #[cfg(feature = "Matrix4")]
609      Matrix::Matrix4(x) => (*x.borrow().index((row-1,col-1))).clone(),
610      #[cfg(feature = "Matrix3")]
611      Matrix::Matrix3(x) => (*x.borrow().index((row-1,col-1))).clone(),
612      #[cfg(feature = "Matrix2")]
613      Matrix::Matrix2(x) => (*x.borrow().index((row-1,col-1))).clone(),
614      #[cfg(feature = "Matrix1")]
615      Matrix::Matrix1(x) => (*x.borrow().index((row-1,col-1))).clone(),
616      #[cfg(feature = "Matrix3x2")]
617      Matrix::Matrix3x2(x) => (*x.borrow().index((row-1,col-1))).clone(),
618      #[cfg(feature = "Matrix2x3")]
619      Matrix::Matrix2x3(x) => (*x.borrow().index((row-1,col-1))).clone(),
620      #[cfg(feature = "MatrixD")]
621      Matrix::DMatrix(x) => (*x.borrow().index((row-1,col-1))).clone(),
622    }
623  }
624
625  pub fn as_vec(&self) -> Vec<T> {
626    match self {
627      #[cfg(feature = "RowVector4")]
628      Matrix::RowVector4(x) => x.borrow().as_slice().to_vec(),
629      #[cfg(feature = "RowVector3")]
630      Matrix::RowVector3(x) => x.borrow().as_slice().to_vec(),
631      #[cfg(feature = "RowVector2")]
632      Matrix::RowVector2(x) => x.borrow().as_slice().to_vec(),
633      #[cfg(feature = "RowVectorD")]
634      Matrix::RowDVector(x) => x.borrow().as_slice().to_vec(),
635      #[cfg(feature = "Vector4")]
636      Matrix::Vector4(x) => x.borrow().as_slice().to_vec(),
637      #[cfg(feature = "Vector3")]
638      Matrix::Vector3(x) => x.borrow().as_slice().to_vec(),
639      #[cfg(feature = "Vector2")]
640      Matrix::Vector2(x) => x.borrow().as_slice().to_vec(),
641      #[cfg(feature = "VectorD")]
642      Matrix::DVector(x) => x.borrow().as_slice().to_vec(),
643      #[cfg(feature = "Matrix4")]
644      Matrix::Matrix4(x) => x.borrow().as_slice().to_vec(),
645      #[cfg(feature = "Matrix3")]
646      Matrix::Matrix3(x) => x.borrow().as_slice().to_vec(),
647      #[cfg(feature = "Matrix2")]
648      Matrix::Matrix2(x) => x.borrow().as_slice().to_vec(),
649      #[cfg(feature = "Matrix1")]
650      Matrix::Matrix1(x) => x.borrow().as_slice().to_vec(),
651      #[cfg(feature = "Matrix3x2")]
652      Matrix::Matrix3x2(x) => x.borrow().as_slice().to_vec(),
653      #[cfg(feature = "Matrix2x3")]
654      Matrix::Matrix2x3(x) => x.borrow().as_slice().to_vec(),
655      #[cfg(feature = "MatrixD")]
656      Matrix::DMatrix(x) => x.borrow().as_slice().to_vec(),
657    }
658  }
659
660}
661
662
663impl ToValue for Matrix<Value> {
664
665  fn to_value(&self) -> Value {
666    Value::MatrixValue(self.clone())
667  }
668  
669}
mech_core/matrix.rs

mech_core/
matrix.rs
