extern crate peroxide;
use peroxide::*;

let a: Vec<f64> = vec![1.,2.,3.,4.];
a.print(); // Convenient to print

let b = c!(1,2,3,4); // R-like macro to declare Vec<f64>
b.print();

let c = seq!(1,10,2); // start, end, step
c.print();

a.clone().into_iter().map(|x| x + 1.).collect::<Vector>().print();

a.fmap(|x| x + 1.).print();

// reduce
a.reduce(0, |x, y| x + y).print();
// zip_with
a.zip_with(|x, y| x + y, &b).print();

// Addition
a.add(&b).print();
a.sub(&b).print();
a.mul(&b).print();
a.div(&b).print();
a.dot(&b).print();

// Function way
let m1 = matrix(vec![1,2,3,4], 2, 2, Row);
let m2 = matrix(c!(1,2,3,4), 2, 2, Row);
let m2_2 = matrix(c!(1,3,2,4), 2, 2, Col);
let m3 = matrix(seq!(1, 4, 1), 2, 2, Row);

// Macro way
let m4 = matrix!(1;4;1, 2, 2, Row);

m4.print();

let m0 = matrix(c!(1.99999, 1, 2, 3), 2, 2, Row);
m0.print();

let a = matrix!(1;4;1, 2, 2, Col);
let b = matrix(c!(5, 6), 2, 1, Col);
let c = cbind!(a, b);
c.print();

let d = matrix!(1;4;1, 2, 2, Row);
let e = matrix(c!(5, 6), 1, 2, Row);
let f = rbind!(d, e);
f.print();

let a = matrix!(1;4;1, 2, 2, Row);
let b = matrix!(1;4;1, 2, 2, Col);

println!("Addition");
(a.clone() + b.clone()).print();
println!("");

println!("Subtraction");
(a.clone() - b.clone()).print();
println!("");

println!("Component-wise multiplication");
(a.clone() * b.clone()).print(); // Component-wise multiplication
println!("");

println!("Matrix multiplication");
(a.clone() % b.clone()).print(); // Matrix multiplication

let a = matrix!(1;4;1, 2, 2, Row);
let pqlu = a.lu(); // Option<PQLU>

// Unwrap process
match pqlu {
    None => println!("No LU Decomposition"),
    Some(abcd) => {
        let (p, q, l, u) = (abcd.p, abcd.q, abcd.l, abcd.u);
        println!("Column Permutation: {:?}", p);
        println!("Row Permutation: {:?}", q);
        println!("Lower Triangular Matrix:\n {}", l);
        println!("Upper Triangular Matrix:\n {}", u);
    }
}

let a = matrix!(1;4;1, 2, 2, Row);
a.det().print();

a.inv().unwrap().print();

// or
println!("");
match a.inv() {
    None => println!("No inverse!"),
    Some(m) => m.print(),
}

let a = matrix!(1;4;1, 2, 2, Row);
a.col(0).print();
a.col(1).print();
a.row(0).print();
a.row(1).print();

a.fmap(|x| x + 1f64).print();