arnaucube
arnaucube/protogalaxy-pocPublic Self-hosted repository
protogalaxy-poc/src/utils.rs
src/utils.rsRaw
 1use ark_ff::fields::PrimeField;
 2use ark_std::cfg_iter;
 3
 4pub fn vec_add<F: PrimeField>(a: &[F], b: &[F]) -> Vec<F> {
 5    assert_eq!(a.len(), b.len());
 6    let mut r: Vec<F> = vec![F::zero(); a.len()];
 7    for i in 0..a.len() {
 8        r[i] = a[i] + b[i];
 9    }
10    r
11}
12
13pub fn vec_sub<F: PrimeField>(a: &[F], b: &[F]) -> Vec<F> {
14    assert_eq!(a.len(), b.len());
15    let mut r: Vec<F> = vec![F::zero(); a.len()];
16    for i in 0..a.len() {
17        r[i] = a[i] - b[i];
18    }
19    r
20}
21
22pub fn vec_scalar_mul<F: PrimeField>(vec: &[F], c: &F) -> Vec<F> {
23    let mut result = vec![F::zero(); vec.len()];
24    for (i, a) in vec.iter().enumerate() {
25        result[i] = *a * c;
26    }
27    result
28}
29pub fn is_zero_vec<F: PrimeField>(vec: &[F]) -> bool {
30    for e in vec {
31        if !e.is_zero() {
32            return false;
33        }
34    }
35    true
36}
37
38pub fn mat_vec_mul<F: PrimeField>(M: &Vec<Vec<F>>, z: &[F]) -> Vec<F> {
39    assert!(!M.is_empty());
40    assert_eq!(M[0].len(), z.len());
41
42    let mut r: Vec<F> = vec![F::zero(); M.len()];
43    for (i, M_i) in M.iter().enumerate() {
44        for (j, M_ij) in M_i.iter().enumerate() {
45            r[i] += *M_ij * z[j];
46        }
47    }
48    r
49}
50
51pub fn hadamard<F: PrimeField>(a: &[F], b: &[F]) -> Vec<F> {
52    assert_eq!(a.len(), b.len());
53    cfg_iter!(a).zip(b).map(|(a, b)| *a * b).collect()
54}
55
56// returns (b, b^2, b^4, ..., b^{2^{t-1}})
57pub fn powers_of_beta<F: PrimeField>(b: F, t: usize) -> Vec<F> {
58    let mut r = vec![F::zero(); t];
59    r[0] = b;
60    for i in 1..t {
61        r[i] = r[i - 1].square();
62    }
63    r
64}
65pub fn all_powers<F: PrimeField>(a: F, n: usize) -> Vec<F> {
66    let mut r = vec![F::zero(); n];
67    // TODO more efficiently
68    for (i, r_i) in r.iter_mut().enumerate() {
69        *r_i = a.pow([i as u64]);
70    }
71    r
72}
73
74pub fn bit_decompose(input: u64, n: usize) -> Vec<bool> {
75    let mut res = Vec::with_capacity(n);
76    let mut i = input;
77    for _ in 0..n {
78        res.push(i & 1 == 1);
79        i >>= 1;
80    }
81    res
82}