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

mech_core/
matrix.rs
