Enum ArithExpr

pub enum ArithExpr<F: Field> {
    Const(F),
    Var(usize),
    Add(Box<ArithExpr<F>>, Box<ArithExpr<F>>),
    Mul(Box<ArithExpr<F>>, Box<ArithExpr<F>>),
    Pow(Box<ArithExpr<F>>, u64),
}

Arithmetic expressions that can be evaluated symbolically.

Arithmetic expressions are trees, where the leaves are either constants or variables, and the non-leaf nodes are arithmetic operations, such as addition, multiplication, etc. They are specific representations of multivariate polynomials.

Variants

Const(F)

Var(usize)

Add(Box<ArithExpr<F>>, Box<ArithExpr<F>>)

Mul(Box<ArithExpr<F>>, Box<ArithExpr<F>>)

Pow(Box<ArithExpr<F>>, u64)

Implementations

impl<F: Field> ArithExpr<F>

pub fn n_vars(&self) -> usize

The number of variables the expression contains.

pub fn degree(&self) -> usize

The total degree of the polynomial the expression represents.

pub fn leading_term(&self) -> Self

Return a new arithmetic expression that contains only the terms of highest degree (useful for interpolation at Karatsuba infinity point).

pub fn leading_term_with_degree(&self) -> (usize, Self)

Same as leading_term, but returns the total degree as the first tuple element as well.

pub fn pow(self, exp: u64) -> Self

pub const fn zero() -> Self

pub const fn one() -> Self

pub fn remap_vars(self, indices: &[usize]) -> Result<Self, Error>

Creates a new expression with the variable indices remapped.

This recursively replaces the variable sub-expressions with an index i with the variable indices[i].

Throws

• Error::IncorrectArgumentLength if indices has length less than the current number of variables

pub fn convert_field<FTgt: Field + From<F>>(&self) -> ArithExpr<FTgt>

pub fn try_convert_field<FTgt: Field + TryFrom<F>>( &self, ) -> Result<ArithExpr<FTgt>, <FTgt as TryFrom<F>>::Error>

pub const fn is_composite(&self) -> bool

Whether expression is a composite node, and not a leaf.

pub fn optimize(&self) -> Self

Creates a new optimized expression.

Recursively rewrites expression for better evaluation performance.

pub fn linear_normal_form(&self) -> Result<LinearNormalForm<F>, Error>

Returns the normal form of an expression if it is linear.

Throws

• Error::NonLinearExpression if the expression is not linear.

impl<F: TowerField> ArithExpr<F>

pub fn binary_tower_level(&self) -> usize

Trait Implementations

impl<F> Add for ArithExpr<F>

where F: Field,

type Output = ArithExpr<F>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<F> AddAssign for ArithExpr<F>

where F: Field,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<F: Clone + Field> Clone for ArithExpr<F>

fn clone(&self) -> ArithExpr<F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug + Field> Debug for ArithExpr<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F> Default for ArithExpr<F>

where F: Field,

fn default() -> Self

Returns the “default value” for a type.

impl<F: Field + DeserializeBytes> DeserializeBytes for ArithExpr<F>

fn deserialize( read_buf: impl Buf, mode: SerializationMode, ) -> Result<Self, SerializationError>

where Self: Sized,

impl<F: Field + Display> Display for ArithExpr<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F> Mul for ArithExpr<F>

where F: Field,

type Output = ArithExpr<F>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<F> MulAssign for ArithExpr<F>

where F: Field,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<F: PartialEq + Field> PartialEq for ArithExpr<F>

fn eq(&self, other: &ArithExpr<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: Field> Product for ArithExpr<F>

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<F: Field + SerializeBytes> SerializeBytes for ArithExpr<F>

fn serialize( &self, write_buf: impl BufMut, mode: SerializationMode, ) -> Result<(), SerializationError>

impl<F> Sub for ArithExpr<F>

where F: Field,

type Output = ArithExpr<F>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<F> SubAssign for ArithExpr<F>

where F: Field,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<F: Field> Sum for ArithExpr<F>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<F: Eq + Field> Eq for ArithExpr<F>

impl<F: Field> StructuralPartialEq for ArithExpr<F>