1use ark_ff::PrimeField;
 2use ark_std::cfg_iter;
 3use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator};
 4
 5#[derive(Clone, Debug, Eq, PartialEq)]
 6pub struct SparseMatrix<F: PrimeField> {
 7    pub n_rows: usize,
 8    pub n_cols: usize,
 9    pub coeffs: Vec<(usize, usize, F)>,
10}
11
12pub fn dense_matrix_to_sparse<F: PrimeField>(m: Vec<Vec<F>>) -> SparseMatrix<F> {
13    let mut r = SparseMatrix::<F> {
14        n_rows: m.len(),
15        n_cols: m[0].len(),
16        coeffs: Vec::new(),
17    };
18    for (i, m_i) in m.iter().enumerate() {
19        for (j, m_ij) in m_i.iter().enumerate() {
20            if !m_ij.is_zero() {
21                r.coeffs.push((i, j, *m_ij));
22            }
23        }
24    }
25    r
26}
27
28pub fn vec_add<F: PrimeField>(a: &[F], b: &[F]) -> Vec<F> {
29    assert_eq!(a.len(), b.len());
30    let mut r: Vec<F> = vec![F::zero(); a.len()];
31    for i in 0..a.len() {
32        r[i] = a[i] + b[i];
33    }
34    r
35}
36
37pub fn vec_sub<F: PrimeField>(a: &[F], b: &[F]) -> Vec<F> {
38    assert_eq!(a.len(), b.len());
39    let mut r: Vec<F> = vec![F::zero(); a.len()];
40    for i in 0..a.len() {
41        r[i] = a[i] - b[i];
42    }
43    r
44}
45
46pub fn vec_scalar_mul<F: PrimeField>(vec: &[F], c: &F) -> Vec<F> {
47    let mut result = vec![F::zero(); vec.len()];
48    for (i, a) in vec.iter().enumerate() {
49        result[i] = *a * c;
50    }
51    result
52}
53
54pub fn is_zero_vec<F: PrimeField>(vec: &[F]) -> bool {
55    for e in vec {
56        if !e.is_zero() {
57            return false;
58        }
59    }
60    true
61}
62
63pub fn mat_vec_mul<F: PrimeField>(M: &Vec<Vec<F>>, z: &[F]) -> Vec<F> {
64    assert!(!M.is_empty());
65    assert_eq!(M[0].len(), z.len());
66
67    let mut r: Vec<F> = vec![F::zero(); M.len()];
68    for (i, M_i) in M.iter().enumerate() {
69        for (j, M_ij) in M_i.iter().enumerate() {
70            r[i] += *M_ij * z[j];
71        }
72    }
73    r
74}
75
76pub fn mat_vec_mul_sparse<F: PrimeField>(matrix: &SparseMatrix<F>, vector: &[F]) -> Vec<F> {
77    let mut res = vec![F::zero(); matrix.n_cols];
78    for &(row, col, value) in matrix.coeffs.iter() {
79        res[row] += value * vector[col];
80    }
81    res
82}
83
84pub fn hadamard<F: PrimeField>(a: &[F], b: &[F]) -> Vec<F> {
85    assert_eq!(a.len(), b.len());
86    cfg_iter!(a).zip(b).map(|(a, b)| *a * b).collect()
87}