initial commit

examples/benchmark.rs

@@ -0,0 +1,42 @@
+use std::env;
+
+use num_bigint::BigInt;
+use num_traits::One;
+use num_traits::Zero;
+use rmath::HMatrix;
+use rmath::Rational;
+use rmath::NumericalMatrix;
+use rand::rngs::StdRng;
+use rand::SeedableRng;
+use rand::RngCore;
+
+fn main( ) {
+    let size = env::args().skip(1).map(|it| {
+        it.parse::<u32>().unwrap()
+    }).take(1).collect::<Vec<u32>>()[0];
+    let mut rand = {
+        let seed = [
+            1,0,1,3, 
+            2,5,0,0, 
+            200,1,0,0, 
+            210,30,0,0,
+            78,134,31,0, 
+            253,11,7,0, 
+            120,169,89,48, 
+            200,0,202,0
+        ];
+        StdRng::from_seed(seed)
+    };
+    let mtx = HMatrix::<Rational<BigInt>>::new(
+        usize::try_from(size).unwrap(),usize::try_from(size).unwrap(), |_| {
+        Rational::new(BigInt::from(rand.next_u32() % (size * 20)) - size * 10, BigInt::one())
+    });
+    let b = HMatrix::<Rational<BigInt>>::new(
+        usize::try_from(size).unwrap(),usize::try_from(size).unwrap(), |_| {
+        Rational::new(BigInt::from(rand.next_u32() % (size * 10)) - (size * 5), BigInt::one())
+    });
+    let lu = mtx.clone().lu().unwrap();
+    let x = lu.solve(&b).unwrap();
+
+    assert!((mtx * x - b).is_zero());
+}

examples/matrix_example.rs

@@ -0,0 +1,51 @@
+use rmath::HMatrix;
+use rmath::SMatrix;
+
+fn main() {
+    let mut acc = 0;
+    let mut m1 = HMatrix::new(3, 3, |_| {
+        let res = acc;
+        acc += 1;
+        res
+    });
+    println!("{}", m1);
+    println!("{}", &m1 + &m1);
+    println!("{}", m1.clone() - m1.clone());
+    println!("{}", &m1 * &m1);
+
+    acc = 0;
+    let mut m2: SMatrix<i32, 3, 3> = SMatrix::new(|_| {
+        let res = acc;
+        acc += 1;
+        res
+    });
+    println!("{}", m2);
+    println!("{}", m2 + m2);
+    println!("{}", m2 - m2);
+    println!("{}", m2 * m2);
+
+    for (i, j, v) in m2 {
+        println!("{} {} {}", i, j, v);
+    }
+    for (i, j, v) in &mut m2 {
+        println!("{} {} {}", i, j, v);
+        *v = 5;
+    }
+    println!("{}", m2);
+    println!("{}", m1 == m1);
+    println!("{}", m1 == &m1 + &m1);
+    println!("{}", m2 == m2);
+    println!("{}", m2 == m2 + m2);
+
+    for (i, j, v) in &mut m1 {
+        println!("{} {} {}", i, j, v);
+        *v = 0;
+    }
+
+    let a: SMatrix<i32, 3, 2> =
+        SMatrix::new(|(i, j)| i32::try_from(i).unwrap() - i32::try_from(j).unwrap());
+    let b: SMatrix<i32, 2, 3> =
+        SMatrix::new(|(i, j)| i32::try_from(i).unwrap() - i32::try_from(j).unwrap());
+    println!("{}", a * b);
+    println!("{}", b * a);
+}