249 lines
7.0 KiB
Rust
249 lines
7.0 KiB
Rust
#![feature(i128_type)]
|
|
#![allow(unused_imports)]
|
|
|
|
extern crate rand;
|
|
|
|
#[macro_use]
|
|
extern crate ff_derive;
|
|
|
|
pub use ff_derive::*;
|
|
|
|
use std::fmt;
|
|
|
|
/// This trait represents an element of a field.
|
|
pub trait Field: Sized +
|
|
Eq +
|
|
Copy +
|
|
Clone +
|
|
Send +
|
|
Sync +
|
|
fmt::Debug +
|
|
'static +
|
|
rand::Rand
|
|
{
|
|
/// Returns the zero element of the field, the additive identity.
|
|
fn zero() -> Self;
|
|
|
|
/// Returns the one element of the field, the multiplicative identity.
|
|
fn one() -> Self;
|
|
|
|
/// Returns true iff this element is zero.
|
|
fn is_zero(&self) -> bool;
|
|
|
|
/// Squares this element.
|
|
fn square(&mut self);
|
|
|
|
/// Doubles this element.
|
|
fn double(&mut self);
|
|
|
|
/// Negates this element.
|
|
fn negate(&mut self);
|
|
|
|
/// Adds another element to this element.
|
|
fn add_assign(&mut self, other: &Self);
|
|
|
|
/// Subtracts another element from this element.
|
|
fn sub_assign(&mut self, other: &Self);
|
|
|
|
/// Multiplies another element by this element.
|
|
fn mul_assign(&mut self, other: &Self);
|
|
|
|
/// Computes the multiplicative inverse of this element, if nonzero.
|
|
fn inverse(&self) -> Option<Self>;
|
|
|
|
/// Exponentiates this element by a power of the base prime modulus via
|
|
/// the Frobenius automorphism.
|
|
fn frobenius_map(&mut self, power: usize);
|
|
|
|
/// Exponentiates this element by a number represented with `u64` limbs,
|
|
/// least significant digit first.
|
|
fn pow<S: AsRef<[u64]>>(&self, exp: S) -> Self
|
|
{
|
|
let mut res = Self::one();
|
|
|
|
for i in BitIterator::new(exp) {
|
|
res.square();
|
|
if i {
|
|
res.mul_assign(self);
|
|
}
|
|
}
|
|
|
|
res
|
|
}
|
|
}
|
|
|
|
/// This trait represents an element of a field that has a square root operation described for it.
|
|
pub trait SqrtField: Field
|
|
{
|
|
/// Returns the square root of the field element, if it is
|
|
/// quadratic residue.
|
|
fn sqrt(&self) -> Option<Self>;
|
|
}
|
|
|
|
/// This trait represents a wrapper around a biginteger which can encode any element of a particular
|
|
/// prime field. It is a smart wrapper around a sequence of `u64` limbs, least-significant digit
|
|
/// first.
|
|
pub trait PrimeFieldRepr: Sized +
|
|
Copy +
|
|
Clone +
|
|
Eq +
|
|
Ord +
|
|
Send +
|
|
Sync +
|
|
fmt::Debug +
|
|
'static +
|
|
rand::Rand +
|
|
AsRef<[u64]> +
|
|
From<u64>
|
|
{
|
|
/// Subtract another reprensetation from this one, returning the borrow bit.
|
|
fn sub_noborrow(&mut self, other: &Self) -> bool;
|
|
|
|
/// Add another representation to this one, returning the carry bit.
|
|
fn add_nocarry(&mut self, other: &Self) -> bool;
|
|
|
|
/// Compute the number of bits needed to encode this number.
|
|
fn num_bits(&self) -> u32;
|
|
|
|
/// Returns true iff this number is zero.
|
|
fn is_zero(&self) -> bool;
|
|
|
|
/// Returns true iff this number is odd.
|
|
fn is_odd(&self) -> bool;
|
|
|
|
/// Returns true iff this number is even.
|
|
fn is_even(&self) -> bool;
|
|
|
|
/// Performs a rightwise bitshift of this number, effectively dividing
|
|
/// it by 2.
|
|
fn div2(&mut self);
|
|
|
|
/// Performs a leftwise bitshift of this number, effectively multiplying
|
|
/// it by 2. Overflow is ignored.
|
|
fn mul2(&mut self);
|
|
}
|
|
|
|
/// This represents an element of a prime field.
|
|
pub trait PrimeField: Field
|
|
{
|
|
/// The prime field can be converted back and forth into this biginteger
|
|
/// representation.
|
|
type Repr: PrimeFieldRepr;
|
|
|
|
/// Convert this prime field element into a biginteger representation.
|
|
fn from_repr(Self::Repr) -> Result<Self, ()>;
|
|
|
|
/// Convert a biginteger reprensentation into a prime field element, if
|
|
/// the number is an element of the field.
|
|
fn into_repr(&self) -> Self::Repr;
|
|
|
|
/// Returns the field characteristic; the modulus.
|
|
fn char() -> Self::Repr;
|
|
|
|
/// Returns how many bits are needed to represent an element of this
|
|
/// field.
|
|
fn num_bits() -> u32;
|
|
|
|
/// Returns how many bits of information can be reliably stored in the
|
|
/// field element.
|
|
fn capacity() -> u32;
|
|
|
|
/// Returns the multiplicative generator of `char()` - 1 order. This element
|
|
/// must also be quadratic nonresidue.
|
|
fn multiplicative_generator() -> Self;
|
|
|
|
/// Returns s such that 2^s * t = `char()` - 1 with t odd.
|
|
fn s() -> usize;
|
|
|
|
/// Returns the 2^s root of unity computed by exponentiating the `multiplicative_generator()`
|
|
/// by t.
|
|
fn root_of_unity() -> Self;
|
|
}
|
|
|
|
pub struct BitIterator<E> {
|
|
t: E,
|
|
n: usize
|
|
}
|
|
|
|
impl<E: AsRef<[u64]>> BitIterator<E> {
|
|
fn new(t: E) -> Self {
|
|
let n = t.as_ref().len() * 64;
|
|
|
|
BitIterator {
|
|
t: t,
|
|
n: n
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<E: AsRef<[u64]>> Iterator for BitIterator<E> {
|
|
type Item = bool;
|
|
|
|
fn next(&mut self) -> Option<bool> {
|
|
if self.n == 0 {
|
|
None
|
|
} else {
|
|
self.n -= 1;
|
|
let part = self.n / 64;
|
|
let bit = self.n - (64 * part);
|
|
|
|
Some(self.t.as_ref()[part] & (1 << bit) > 0)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_bit_iterator() {
|
|
let mut a = BitIterator::new([0xa953d79b83f6ab59, 0x6dea2059e200bd39]);
|
|
let expected = "01101101111010100010000001011001111000100000000010111101001110011010100101010011110101111001101110000011111101101010101101011001";
|
|
|
|
for e in expected.chars() {
|
|
assert!(a.next().unwrap() == (e == '1'));
|
|
}
|
|
|
|
assert!(a.next().is_none());
|
|
|
|
let expected = "1010010101111110101010000101101011101000011101110101001000011001100100100011011010001011011011010001011011101100110100111011010010110001000011110100110001100110011101101000101100011100100100100100001010011101010111110011101011000011101000111011011101011001";
|
|
|
|
let mut a = BitIterator::new([0x429d5f3ac3a3b759, 0xb10f4c66768b1c92, 0x92368b6d16ecd3b4, 0xa57ea85ae8775219]);
|
|
|
|
for e in expected.chars() {
|
|
assert!(a.next().unwrap() == (e == '1'));
|
|
}
|
|
|
|
assert!(a.next().is_none());
|
|
}
|
|
|
|
/// Calculate a - b - borrow, returning the result and modifying
|
|
/// the borrow value.
|
|
#[inline(always)]
|
|
pub fn sbb(a: u64, b: u64, borrow: &mut u64) -> u64 {
|
|
let tmp = (1u128 << 64) + (a as u128) - (b as u128) - (*borrow as u128);
|
|
|
|
*borrow = if tmp >> 64 == 0 { 1 } else { 0 };
|
|
|
|
tmp as u64
|
|
}
|
|
|
|
/// Calculate a + b + carry, returning the sum and modifying the
|
|
/// carry value.
|
|
#[inline(always)]
|
|
pub fn adc(a: u64, b: u64, carry: &mut u64) -> u64 {
|
|
let tmp = (a as u128) + (b as u128) + (*carry as u128);
|
|
|
|
*carry = (tmp >> 64) as u64;
|
|
|
|
tmp as u64
|
|
}
|
|
|
|
/// Calculate a + (b * c) + carry, returning the least significant digit
|
|
/// and setting carry to the most significant digit.
|
|
#[inline(always)]
|
|
pub fn mac_with_carry(a: u64, b: u64, c: u64, carry: &mut u64) -> u64 {
|
|
let tmp = (a as u128) + (b as u128) * (c as u128) + (*carry as u128);
|
|
|
|
*carry = (tmp >> 64) as u64;
|
|
|
|
tmp as u64
|
|
}
|