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

mech_core/
matrix.rs
