Skip to main content

dory_pcs/backends/arkworks/
ark_field.rs

1#![allow(missing_docs)]
2#![allow(clippy::missing_errors_doc)]
3#![allow(clippy::missing_panics_doc)]
4
5use crate::primitives::arithmetic::Field;
6use ark_bn254::Fr;
7use ark_ff::{Field as ArkField, UniformRand, Zero as ArkZero};
8use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
9use ark_std::ops::{Add, Mul, Neg, Sub};
10
11#[derive(Clone, Copy, PartialEq, Eq, Debug, CanonicalSerialize, CanonicalDeserialize)]
12pub struct ArkFr(pub Fr);
13
14impl Field for ArkFr {
15    fn zero() -> Self {
16        ArkFr(Fr::from(0u64))
17    }
18
19    fn one() -> Self {
20        ArkFr(Fr::from(1u64))
21    }
22
23    fn is_zero(&self) -> bool {
24        ArkZero::is_zero(&self.0)
25    }
26
27    fn add(&self, rhs: &Self) -> Self {
28        ArkFr(self.0 + rhs.0)
29    }
30
31    fn sub(&self, rhs: &Self) -> Self {
32        ArkFr(self.0 - rhs.0)
33    }
34
35    fn mul(&self, rhs: &Self) -> Self {
36        ArkFr(self.0 * rhs.0)
37    }
38
39    fn inv(self) -> Option<Self> {
40        ArkField::inverse(&self.0).map(ArkFr)
41    }
42
43    fn random() -> Self {
44        ArkFr(Fr::rand(&mut rand_core::OsRng))
45    }
46
47    fn from_u64(val: u64) -> Self {
48        ArkFr(Fr::from(val))
49    }
50
51    fn from_i64(val: i64) -> Self {
52        if val >= 0 {
53            ArkFr(Fr::from(val as u64))
54        } else {
55            ArkFr(-Fr::from((-val) as u64))
56        }
57    }
58}
59
60impl Add for ArkFr {
61    type Output = Self;
62    fn add(self, rhs: Self) -> Self {
63        ArkFr(self.0 + rhs.0)
64    }
65}
66
67impl Sub for ArkFr {
68    type Output = Self;
69    fn sub(self, rhs: Self) -> Self {
70        ArkFr(self.0 - rhs.0)
71    }
72}
73
74impl Mul for ArkFr {
75    type Output = Self;
76    fn mul(self, rhs: Self) -> Self {
77        ArkFr(self.0 * rhs.0)
78    }
79}
80
81impl Neg for ArkFr {
82    type Output = Self;
83    fn neg(self) -> Self {
84        ArkFr(-self.0)
85    }
86}
87
88impl<'a> Add<&'a ArkFr> for ArkFr {
89    type Output = ArkFr;
90    fn add(self, rhs: &'a ArkFr) -> ArkFr {
91        ArkFr(self.0 + rhs.0)
92    }
93}
94
95impl<'a> Sub<&'a ArkFr> for ArkFr {
96    type Output = ArkFr;
97    fn sub(self, rhs: &'a ArkFr) -> ArkFr {
98        ArkFr(self.0 - rhs.0)
99    }
100}
101
102impl<'a> Mul<&'a ArkFr> for ArkFr {
103    type Output = ArkFr;
104    fn mul(self, rhs: &'a ArkFr) -> ArkFr {
105        ArkFr(self.0 * rhs.0)
106    }
107}