Cargo fmt

Author: Axect

src/fuga/mod.rs

@@ -110,53 +110,28 @@ pub use crate::macros::{julia_macro::*, matlab_macro::*, r_macro::*};
 pub use crate::traits::{
     fp::{FPMatrix, FPVector},
     general::Algorithm,
-    math::{InnerProduct, LinearOp, Norm, Normed, Vector, VectorProduct, MatrixProduct},
+    math::{InnerProduct, LinearOp, MatrixProduct, Norm, Normed, Vector, VectorProduct},
     mutable::{MutFP, MutMatrix},
     num::{ExpLogOps, Number, NumberVector, PowOps, Real, TrigOps},
     pointer::{MatrixPtr, Oxide, Redox},
-    sugar::{Scalable, ScalableMut, VecOps},
     stable::StableFn,
+    sugar::{Scalable, ScalableMut, VecOps},
 };
 
 #[allow(unused_imports)]
-pub use crate::structure::{
-    dual::*, 
-    hyper_dual::*, 
-    matrix::*, 
-    polynomial::*, 
-    vector::*
-};
+pub use crate::structure::{dual::*, hyper_dual::*, matrix::*, polynomial::*, vector::*};
 
-pub use crate::util::{
-    api::*, 
-    low_level::*, 
-    non_macro::*, 
-    print::*, 
-    useful::*, 
-    wrapper::*
-};
+pub use crate::util::{api::*, low_level::*, non_macro::*, print::*, useful::*, wrapper::*};
 
 #[allow(unused_imports)]
-pub use crate::statistics::{
-    dist::*, 
-    ops::*, 
-    rand::*, 
-    stat::*
-};
+pub use crate::statistics::{dist::*, ops::*, rand::*, stat::*};
 
 #[allow(unused_imports)]
 pub use crate::special::function::*;
 
 #[allow(unused_imports)]
 pub use crate::numerical::{
-    eigen::*, 
-    integral::*, 
-    interp::*, 
-    ode::*, 
-    optimize::*, 
-    spline::*, 
-    utils::*,
-    root::*,
+    eigen::*, integral::*, interp::*, ode::*, optimize::*, root::*, spline::*, utils::*,
 };
 
 #[allow(unused_imports)]
@@ -177,6 +152,7 @@ pub use crate::structure::ad::*;
 // Enums
 // =============================================================================
 pub use crate::numerical::integral::Integral::{GaussLegendre, NewtonCotes};
+pub use crate::numerical::root::RootFind::{Bisection, FalsePosition, Newton, Secant};
 pub use crate::statistics::stat::QType::{
     Type1, Type2, Type3, Type4, Type5, Type6, Type7, Type8, Type9,
 };
@@ -185,4 +161,3 @@ pub use crate::structure::matrix::{
     SolveKind::{LU, WAZ},
 };
 pub use crate::traits::num::Number::{D, F};
-pub use crate::numerical::root::RootFind::{Bisection, FalsePosition, Newton, Secant};

src/numerical/mod.rs

@@ -8,6 +8,6 @@ pub mod interp;
 pub mod newton;
 pub mod ode;
 pub mod optimize;
+pub mod root;
 pub mod spline;
 pub mod utils;
-pub mod root;

src/numerical/root.rs

@@ -108,7 +108,7 @@ pub mod simpler;
 pub use crate::traits::{
     fp::{FPMatrix, FPVector},
     general::Algorithm,
-    math::{InnerProduct, LinearOp, Vector},
+    math::{InnerProduct, LinearOp, MatrixProduct, Vector, VectorProduct},
     mutable::{MutFP, MutMatrix},
     num::{ExpLogOps, Number, NumberVector, PowOps, Real, TrigOps},
     pointer::{MatrixPtr, Oxide, Redox},
@@ -122,24 +122,8 @@ pub use crate::structure::{
     dual::*,
     hyper_dual::*,
     matrix::{
-        combine,
-        diag,
-        gemm,
-        gemv,
-        gen_householder,
-        inv_l,
-        inv_u,
-        matrix,
-        ml_matrix,
-        py_matrix,
-        r_matrix,
-        Col,
-        Matrix,
-        Row,
-        Shape,
-        PQLU,
-        QR,
-        WAZD,
+        combine, diag, gemm, gemv, gen_householder, inv_l, inv_u, matrix, ml_matrix, py_matrix,
+        r_matrix, Col, Matrix, Row, Shape, PQLU, QR, WAZD,
     },
     polynomial::*,
     vector::*,
@@ -148,22 +132,10 @@ pub use crate::structure::{
 pub use simpler::{solve, SimplerLinearAlgebra};
 
 #[allow(unused_imports)]
-pub use crate::util::{
-    api::*, 
-    low_level::*,
-    non_macro::*,
-    print::*,
-    useful::*,
-    wrapper::*,
-};
+pub use crate::util::{api::*, low_level::*, non_macro::*, print::*, useful::*, wrapper::*};
 
 #[allow(unused_imports)]
-pub use crate::statistics::{
-    dist::*,
-    ops::*,
-    rand::*,
-    stat::*,
-};
+pub use crate::statistics::{dist::*, ops::*, rand::*, stat::*};
 
 #[allow(unused_imports)]
 pub use crate::special::function::*;
@@ -174,9 +146,9 @@ pub use crate::numerical::{
     interp::*,
     ode::*,
     optimize::*,
+    root::{bisection, false_position, newton, secant},
     spline::*,
     utils::*,
-    root::{bisection, secant, newton, false_position},
 };
 
 pub use simpler::{eigen, integrate};

src/prelude/mod.rs

@@ -135,10 +135,7 @@ pub use self::OPDist::*;
 pub use self::TPDist::*;
 use crate::special::function::*;
 //use statistics::rand::ziggurat;
-use crate::statistics::{
-    stat::Statistics,
-    ops::C,
-};
+use crate::statistics::{ops::C, stat::Statistics};
 use std::convert::Into;
 use std::f64::consts::E;
 
@@ -316,7 +313,11 @@ impl<T: PartialOrd + SampleUniform + Copy + Into<f64>> RNG for TPDist<T> {
             Binomial(num, mu) => {
                 let mut rng = thread_rng();
                 let binom = rand_distr::Binomial::new(*num as u64, (*mu).into()).unwrap();
-                binom.sample_iter(&mut rng).take(n).map(|t| t as f64).collect()
+                binom
+                    .sample_iter(&mut rng)
+                    .take(n)
+                    .map(|t| t as f64)
+                    .collect()
             }
 
             Normal(m, s) => {
@@ -414,7 +415,7 @@ impl<T: PartialOrd + SampleUniform + Copy + Into<f64>> RNG for TPDist<T> {
                 let n = *n;
                 let mu = (*mu).into();
                 let m = x.into() as usize;
-                (C(n, m) as f64) * mu.powi(m as i32) * (1f64 - mu).powi((n - m) as i32) 
+                (C(n, m) as f64) * mu.powi(m as i32) * (1f64 - mu).powi((n - m) as i32)
             }
             Normal(m, s) => {
                 let mean = (*m).into();

src/statistics/dist.rs

@@ -122,16 +122,16 @@ use crate::traits::{
     stable::StableFn,
 };
 use peroxide_ad::{
-    ad_display, ad_impl, ad_impl_ad, ad_impl_add, ad_impl_div, ad_impl_double_ended_iter,
-    ad_impl_exact_size_iter, ad_impl_explogops, ad_impl_from, ad_impl_from_iter, ad_impl_index,
-    ad_impl_into_iter, ad_impl_iter, ad_impl_mul, ad_impl_neg, ad_impl_powops, ad_impl_sub,
-    ad_impl_trigops, ad_iter_def, ad_struct_def, ad_impl_from_type, ad_impl_add_f64, ad_impl_sub_f64,
-    ad_impl_mul_f64, ad_impl_div_f64, f64_impl_add_ad, f64_impl_sub_ad, f64_impl_mul_ad, f64_impl_div_ad,
-    f64_impl_from_ad, ad_impl_stable_fn, def_ad
+    ad_display, ad_impl, ad_impl_ad, ad_impl_add, ad_impl_add_f64, ad_impl_div, ad_impl_div_f64,
+    ad_impl_double_ended_iter, ad_impl_exact_size_iter, ad_impl_explogops, ad_impl_from,
+    ad_impl_from_iter, ad_impl_from_type, ad_impl_index, ad_impl_into_iter, ad_impl_iter,
+    ad_impl_mul, ad_impl_mul_f64, ad_impl_neg, ad_impl_powops, ad_impl_stable_fn, ad_impl_sub,
+    ad_impl_sub_f64, ad_impl_trigops, ad_iter_def, ad_struct_def, def_ad, f64_impl_add_ad,
+    f64_impl_div_ad, f64_impl_from_ad, f64_impl_mul_ad, f64_impl_sub_ad,
 };
 use std::iter::FromIterator;
-use std::ops::{Add, Div, Index, IndexMut, Mul, Neg, Sub};
 use std::marker::PhantomData;
+use std::ops::{Add, Div, Index, IndexMut, Mul, Neg, Sub};
 
 ad_struct_def!();
 ad_display!();
@@ -301,7 +301,7 @@ impl<F: Fn(T) -> T, T> ADLift<F, T> {
     pub fn new(f: F) -> Self {
         Self {
             f: Box::new(f),
-            _marker: PhantomData
+            _marker: PhantomData,
         }
     }
 
@@ -329,6 +329,5 @@ impl<F: Fn(T) -> T, T: AD> StableFn<AD1> for ADLift<F, T> {
 //
 //impl<F: FnOnce<(T)>, T> FnOnce<f64> for ADLift<F> {
 //    type Output = f64;
-//    
+//
 //}
-

src/structure/ad.rs

@@ -458,12 +458,12 @@ use crate::numerical::eigen::{eigen, EigenMethod};
 use crate::traits::{
     fp::{FPMatrix, FPVector},
     general::Algorithm,
-    math::{InnerProduct, LinearOp, Norm, Normed, Vector, MatrixProduct},
+    math::{InnerProduct, LinearOp, MatrixProduct, Norm, Normed, Vector},
     mutable::MutMatrix,
 };
 use crate::util::{
     low_level::{copy_vec_ptr, swap_vec_ptr},
-    non_macro::{eye, zeros, cbind, rbind},
+    non_macro::{cbind, eye, rbind, zeros},
     useful::{nearly_eq, tab},
 };
 use std::cmp::{max, min};
@@ -1402,18 +1402,17 @@ impl MatrixProduct for Matrix {
     fn kronecker(&self, other: &Self) -> Self {
         let r1 = self.row;
         let c1 = self.col;
-        
+
         let mut result = self[(0, 0)] * other;
 
-        for j in 1 .. c1 {
+        for j in 1..c1 {
             let n = self[(0, j)] * other;
             result = cbind(result, n);
         }
-                
 
-        for i in 1 .. r1 {
+        for i in 1..r1 {
             let mut m = self[(i, 0)] * other;
-            for j in 1 .. c1 {
+            for j in 1..c1 {
                 let n = self[(i, j)] * other;
                 m = cbind(m, n);
             }
@@ -1429,9 +1428,9 @@ impl MatrixProduct for Matrix {
         let r = self.row;
         let c = self.col;
 
-        let mut m = matrix(vec![0f64; r*c], r, c, self.shape);
-        for i in 0 .. r {
-            for j in 0 .. c {
+        let mut m = matrix(vec![0f64; r * c], r, c, self.shape);
+        for i in 0..r {
+            for j in 0..c {
                 m[(i, j)] = self[(i, j)] * other[(i, j)]
             }
         }

src/structure/matrix.rs

@@ -1,5 +1,5 @@
-use std::convert::Into;
 use crate::structure::matrix::Matrix;
+use std::convert::Into;
 
 /// Mathematical Vector
 ///

src/traits/math.rs

@@ -4,5 +4,5 @@ pub mod math;
 pub mod mutable;
 pub mod num;
 pub mod pointer;
-pub mod sugar;
 pub mod stable;
+pub mod sugar;

src/traits/mod.rs

@@ -98,8 +98,8 @@ fn test_col_map() {
 
 #[test]
 fn test_outer() {
-    let a = c!(1,2,3);
-    let b = c!(4,5,6);
+    let a = c!(1, 2, 3);
+    let b = c!(4, 5, 6);
     let c = a.outer(&b);
     assert_eq!(c, ml_matrix("4 5 6;8 10 12;12 15 18"));
 }