v0.5.1 upgrade whole lib into generic-type-based. API changed. more safer than before. update Cargo.toml

Author: LEXUGE

Cargo.toml

@@ -1,11 +1,12 @@
 [package]
 name = "lib_xch"
-version = "0.4.0"
+version = "0.5.1"
 authors = ["LEXUGE <LEXUGEyky@outlook.com>"]
 description = "Crate xch-ceb's official lib"
 license = "GPL-3.0"
 repository = "https://github.com/LEXUGE/lib-xch-ceb"
 
 [dependencies]
-lazy_static = "^1.x"
+lazy_static = "^1.0"
 regex = "^0.2"
+num-traits = "^0.2"

src/balancer_mod/frac_util.rs

@@ -22,34 +22,34 @@ use super::math_methods::{gcd, lcm};
 use handler::ErrorCases::UndefinedFrac;
 use handler::ErrorCases;
 use public::Operator::{Abs, Add, Div, Mul, Sub};
-use public::safe_calc;
+use public::{safe_calc, CheckedType};
 
-fn rfcd(a: &Frac, b: &Frac) -> Result<(i32, i32, i32), ErrorCases> {
+fn rfcd<T: CheckedType>(a: &Frac<T>, b: &Frac<T>) -> Result<(T, T, T), ErrorCases> {
     // reduction of fractions to a common denominator
     let d = lcm(a.denominator, b.denominator)?;
-    let mut a_n = safe_calc(d, a.denominator, &Div)?;
-    let mut b_n = safe_calc(d, b.denominator, &Div)?;
-    a_n = safe_calc(a_n, a.numerator, &Mul)?;
-    b_n = safe_calc(b_n, b.numerator, &Mul)?;
+    let mut a_n = safe_calc(&d, &a.denominator, &Div)?;
+    let mut b_n = safe_calc(&d, &b.denominator, &Div)?;
+    a_n = safe_calc(&a_n, &a.numerator, &Mul)?;
+    b_n = safe_calc(&b_n, &b.numerator, &Mul)?;
     Ok((a_n, b_n, d))
 }
 
 #[derive(Clone, Copy)]
-pub struct Frac {
-    pub numerator: i32,
-    pub denominator: i32,
+pub struct Frac<T: CheckedType> {
+    pub numerator: T,
+    pub denominator: T,
 }
 
-impl Frac {
-    pub fn new(numerator: i32, denominator: i32) -> Self {
+impl<T: CheckedType> Frac<T> {
+    pub fn new(numerator: T, denominator: T) -> Self {
         Self {
             numerator,
             denominator,
         }
     }
 
     pub fn check(&self) -> Result<bool, ErrorCases> {
-        if self.denominator == 0 {
+        if self.denominator == T::zero() {
             Err(UndefinedFrac)
         } else {
             Ok(true)
@@ -60,31 +60,31 @@ impl Frac {
         self.check()?;
         let gcd = gcd(self.numerator, self.denominator)?;
         Ok(Self {
-            numerator: safe_calc(self.numerator, gcd, &Div)?,
-            denominator: safe_calc(self.denominator, gcd, &Div)?,
+            numerator: safe_calc(&self.numerator, &gcd, &Div)?,
+            denominator: safe_calc(&self.denominator, &gcd, &Div)?,
         })
     }
 
     pub fn abs(&self) -> Result<Self, ErrorCases> {
         self.check()?;
         let mut tmp = Self {
-            numerator: safe_calc(self.numerator, 0, &Abs)?,
-            denominator: safe_calc(self.denominator, 0, &Abs)?,
+            numerator: safe_calc(&self.numerator, &T::zero(), &Abs)?,
+            denominator: safe_calc(&self.denominator, &T::zero(), &Abs)?,
         };
         tmp = tmp.simple()?;
         tmp.check()?;
         Ok(tmp)
     }
 }
 
-impl ops::Add for Frac {
+impl<T: CheckedType> ops::Add for Frac<T> {
     type Output = Result<Self, ErrorCases>;
     fn add(self, b: Self) -> Result<Self, ErrorCases> {
         self.check()?;
         b.check()?;
         let (a_n, b_n, d) = rfcd(&self, &b)?;
         let mut tmp = Self {
-            numerator: safe_calc(a_n, b_n, &Add)?,
+            numerator: safe_calc(&a_n, &b_n, &Add)?,
             denominator: d,
         };
         tmp = tmp.simple()?;
@@ -93,14 +93,14 @@ impl ops::Add for Frac {
     }
 }
 
-impl ops::Sub for Frac {
+impl<T: CheckedType> ops::Sub for Frac<T> {
     type Output = Result<Self, ErrorCases>;
     fn sub(self, b: Self) -> Result<Self, ErrorCases> {
         self.check()?;
         b.check()?;
         let (a_n, b_n, d) = rfcd(&self, &b)?;
         let mut tmp = Self {
-            numerator: safe_calc(a_n, b_n, &Sub)?,
+            numerator: safe_calc(&a_n, &b_n, &Sub)?,
             denominator: d,
         };
         tmp = tmp.simple()?;
@@ -109,37 +109,37 @@ impl ops::Sub for Frac {
     }
 }
 
-impl ops::Mul for Frac {
+impl<T: CheckedType> ops::Mul for Frac<T> {
     type Output = Result<Self, ErrorCases>;
     fn mul(self, b: Self) -> Result<Self, ErrorCases> {
         self.check()?;
         b.check()?;
         let mut tmp = Self {
-            numerator: safe_calc(self.numerator, b.numerator, &Mul)?,
-            denominator: safe_calc(self.denominator, b.denominator, &Mul)?,
+            numerator: safe_calc(&self.numerator, &b.numerator, &Mul)?,
+            denominator: safe_calc(&self.denominator, &b.denominator, &Mul)?,
         };
         tmp = tmp.simple()?;
         tmp.check()?;
         Ok(tmp)
     }
 }
 
-impl ops::Div for Frac {
+impl<T: CheckedType> ops::Div for Frac<T> {
     type Output = Result<Self, ErrorCases>;
     fn div(self, b: Self) -> Result<Self, ErrorCases> {
         self.check()?;
         b.check()?;
         let mut tmp = Self {
-            numerator: safe_calc(self.numerator, b.denominator, &Mul)?,
-            denominator: safe_calc(self.denominator, b.numerator, &Mul)?,
+            numerator: safe_calc(&self.numerator, &b.denominator, &Mul)?,
+            denominator: safe_calc(&self.denominator, &b.numerator, &Mul)?,
         };
         tmp = tmp.simple()?;
         tmp.check()?;
         Ok(tmp)
     }
 }
 
-impl PartialOrd for Frac {
+impl<T: CheckedType> PartialOrd for Frac<T> {
     fn partial_cmp(&self, b: &Self) -> Option<Ordering> {
         if self.check().is_err() || b.check().is_err() {
             None
@@ -148,19 +148,19 @@ impl PartialOrd for Frac {
                 Ok(s) => s,
                 Err(e) => panic!("[Ord] `lcm` Err: {:?}", e),
             };
-            let mut a_n = match safe_calc(d, self.denominator, &Div) {
+            let mut a_n = match safe_calc(&d, &self.denominator, &Div) {
                 Ok(s) => s,
                 Err(e) => panic!("[Ord] Err: {:?}", e),
             };
-            let mut b_n = match safe_calc(d, b.denominator, &Div) {
+            let mut b_n = match safe_calc(&d, &b.denominator, &Div) {
                 Ok(s) => s,
                 Err(e) => panic!("[Ord] Err: {:?}", e),
             };
-            a_n = match safe_calc(a_n, self.numerator, &Mul) {
+            a_n = match safe_calc(&a_n, &self.numerator, &Mul) {
                 Ok(s) => s,
                 Err(e) => panic!("[Ord] Err: {:?}", e),
             };
-            b_n = match safe_calc(b_n, b.numerator, &Mul) {
+            b_n = match safe_calc(&b_n, &b.numerator, &Mul) {
                 Ok(s) => s,
                 Err(e) => panic!("[Ord] Err: {:?}", e),
             };
@@ -169,7 +169,7 @@ impl PartialOrd for Frac {
     }
 }
 
-impl PartialEq for Frac {
+impl<T: CheckedType> PartialEq for Frac<T> {
     fn eq(&self, b: &Self) -> bool {
         if b.check().is_err() || self.check().is_err() {
             panic!("[Eq] UndefinedFrac")

src/balancer_mod/gauss_eliminate.rs

@@ -16,20 +16,22 @@
 // Overall: This is the source code of the AlphaForce Balancer.
 
 use std::collections::HashMap;
+// inside uses
 use handler::{ErrorCases, ResultHandler};
 use handler::ErrorCases::Unsolvable;
 use handler::WarnCases::{FreeVariablesDetected, NoWarn};
 use super::frac_util::Frac;
+use public::CheckedType;
 
-pub struct GaussianElimination {
-    matrix_a: Vec<Vec<Frac>>, // A n*n matrix.
-    matrix_b: Vec<Frac>,      // A n*1 matrix.
+pub struct GaussianElimination<T: CheckedType> {
+    matrix_a: Vec<Vec<Frac<T>>>, // A n*n matrix.
+    matrix_b: Vec<Frac<T>>,      // A n*1 matrix.
     n: usize,
     m: usize,
 }
 
-impl GaussianElimination {
-    pub fn new(matrix_a: Vec<Vec<Frac>>, matrix_b: Vec<Frac>, n: usize, m: usize) -> Self {
+impl<T: CheckedType> GaussianElimination<T> {
+    pub fn new(matrix_a: Vec<Vec<Frac<T>>>, matrix_b: Vec<Frac<T>>, n: usize, m: usize) -> Self {
         // Create a GaussianElimination Solution.
         Self {
             matrix_a,
@@ -39,7 +41,7 @@ impl GaussianElimination {
         }
     }
 
-    pub fn solve(&mut self) -> Result<ResultHandler<Vec<Frac>>, ErrorCases> {
+    pub fn solve(&mut self) -> Result<ResultHandler<Vec<Frac<T>>>, ErrorCases> {
         // The Gaussian-Jordan Algorithm
         for i in 0..self.n {
             let leftmosti = match self.get_leftmost_row(i) {
@@ -54,7 +56,7 @@ impl GaussianElimination {
                 None => continue,
             };
             let maxi = self.get_max_abs_row(i, j)?;
-            if self.matrix_a[maxi][j].numerator != 0 {
+            if self.matrix_a[maxi][j].numerator != T::zero() {
                 self.matrix_a.swap(i, maxi);
                 self.matrix_b.swap(i, maxi); // swap row i and maxi in matrix_a and matrix_b
                 {
@@ -85,19 +87,19 @@ impl GaussianElimination {
                 self.matrix_b[u] = (self.matrix_b[u] - v[self.m])?;
             }
         } // RREF
-        let mut ans: Vec<Frac> = vec![Frac::new(0, 1); self.m];
+        let mut ans: Vec<Frac<T>> = vec![Frac::new(T::zero(), T::one()); self.m];
         let pivots = self.check()?;
         let mut free_variable = false;
         for i in (0..self.m).rev() {
             if pivots.contains_key(&i) {
-                let mut sum = Frac::new(0, 1);
+                let mut sum = Frac::new(T::zero(), T::one());
                 for (k, item) in ans.iter().enumerate().take(self.m).skip(i + 1) {
                     sum = (sum + (self.matrix_a[pivots[&i]][k] * (*item))?)?;
                 }
                 ans[i] = ((self.matrix_b[pivots[&i]] - sum)? / self.matrix_a[pivots[&i]][i])?;
             } else {
                 free_variable = true;
-                ans[i] = Frac::new(1, 1); // set all free variables = 1/1.
+                ans[i] = Frac::new(T::one(), T::one()); // set all free variables = 1/1.
             }
         }
         Ok(ResultHandler {
@@ -116,8 +118,8 @@ impl GaussianElimination {
             if self.get_pivot(i).is_some() {
                 pivots.insert(self.get_pivot(i).unwrap(), i); // safe unwrap
             }
-            if self.matrix_a[i] == vec![Frac::new(0, 1); self.n + 1]
-                && self.matrix_b[i] != Frac::new(0, 1)
+            if self.matrix_a[i] == vec![Frac::new(T::zero(), T::one()); self.n + 1]
+                && self.matrix_b[i] != Frac::new(T::zero(), T::one())
             {
                 return Err(Unsolvable);
             }
@@ -127,7 +129,7 @@ impl GaussianElimination {
 
     fn get_pivot(&self, row: usize) -> Option<usize> {
         for column in 0..self.m {
-            if self.matrix_a[row][column] != Frac::new(0, 1) {
+            if self.matrix_a[row][column] != Frac::new(T::zero(), T::one()) {
                 return Some(column);
             }
         }
@@ -162,16 +164,16 @@ impl GaussianElimination {
         }
     }
 
-    fn mul_row(&self, row: usize, multiplicator: Frac) -> Result<Vec<Frac>, ErrorCases> {
-        let mut v: Vec<Frac> = Vec::new();
+    fn mul_row(&self, row: usize, multiplicator: Frac<T>) -> Result<Vec<Frac<T>>, ErrorCases> {
+        let mut v: Vec<Frac<T>> = Vec::new();
         for column in 0..self.m {
             v.push((self.matrix_a[row][column] * multiplicator)?);
         }
         v.push((self.matrix_b[row] * multiplicator)?);
         Ok(v)
     }
 
-    fn divide_row(&mut self, row: usize, divisor: Frac) -> Result<bool, ErrorCases> {
+    fn divide_row(&mut self, row: usize, divisor: Frac<T>) -> Result<bool, ErrorCases> {
         for column in 0..self.m {
             self.matrix_a[row][column] = (self.matrix_a[row][column] / divisor)?;
         }

src/balancer_mod/math_methods.rs

@@ -15,26 +15,27 @@
 
 // Overall: This is the source code of the AlphaForce Balancer.
 
+// inside uses
 use handler::ErrorCases;
-use public::{safe_calc, Operator};
+use public::{safe_calc, CheckedType, Operator};
 
-pub fn gcd(mut a: i32, mut b: i32) -> Result<i32, ErrorCases> {
-    let mut t: i32;
-    while b != 0 {
+pub fn gcd<T: CheckedType + PartialEq>(mut a: T, mut b: T) -> Result<T, ErrorCases> {
+    let mut t: T;
+    while b != T::zero() {
         t = b;
-        b = safe_calc(a, b, &Operator::Rem)?;
+        b = safe_calc(&a, &b, &Operator::Rem)?;
         a = t;
     }
     Ok(a)
 }
 
-pub fn lcm(a: i32, b: i32) -> Result<i32, ErrorCases> {
-    let a_b = safe_calc(a, b, &Operator::Mul)?;
-    safe_calc(a_b, gcd(a, b)?, &Operator::Div)
+pub fn lcm<T: CheckedType>(a: T, b: T) -> Result<T, ErrorCases> {
+    let a_b = safe_calc(&a, &b, &Operator::Mul)?;
+    safe_calc(&a_b, &gcd(a, b)?, &Operator::Div)
 }
 
-pub fn nlcm(v: Vec<i32>) -> Result<i32, ErrorCases> {
-    let mut ans: i32 = 1;
+pub fn nlcm<T: CheckedType>(v: Vec<T>) -> Result<T, ErrorCases> {
+    let mut ans: T = T::one();
     for i in v {
         ans = lcm(ans, i)?;
     }