fn par_norm(&self, kind: Norm) -> f64 {
        match kind {
            Norm::F => {
                let mut s = 0f64;
                for i in 0..self.data.len() {
                    s += self.data[i].powi(2);
                }
                s.sqrt()
            }
            Norm::Lpq(p, q) => {
                let s = (0..self.col)
                    .into_par_iter()
                    .map(|j| {
                        let s_row = (0..self.row)
                            .into_iter()
                            .map(|i| self[(i, j)].powi(p as i32))
                            .sum::<f64>();
                        s_row.powf(q / p)
                    })
                    .sum::<f64>();
                s.powf(1f64 / q)
            }
            Norm::L1 => {
                let mut m = f64::MIN;
                match self.shape {
                    Row => self.change_shape().norm(Norm::L1),
                    Col => {
                        for c in 0..self.col {
                            let s = self.col(c).par_iter().sum();
                            if s > m {
                                m = s;
                            }
                        }
                        m
                    }
                }
            }
            Norm::LInf => {
                let mut m = f64::MIN;
                match self.shape {
                    Col => self.change_shape().norm(Norm::LInf),
                    Row => {
                        for r in 0..self.row {
                            let s = self.row(r).iter().sum();
                            if s > m {
                                m = s;
                            }
                        }
                        m
                    }
                }
            }
            Norm::L2 => {
                let a = &self.t() * self;
                let eig = eigen(&a, EigenMethod::Jacobi);
                eig.eigenvalue.norm(Norm::LInf)
            }
            Norm::Lp(_) => unimplemented!(),
        }
    }
Parallel version of norm

# Example
```
use peroxide::fuga::*;

let a = ml_matrix("1 2;3 4");
assert_eq!(a.par_norm(Norm::F), (1f64 + 4f64 + 9f64 + 16f64).sqrt());
```
src/structure/matrix.rs