Struct PointEvaluator 

pub struct PointEvaluator<'a> {
    pub mask: TreeVec<ColumnVec<&'a Vec<SecureField>>>,
    pub evaluation_accumulator: &'a mut PointEvaluationAccumulator,
    pub col_index: Vec<usize>,
    pub denom_inverse: SecureField,
    pub logup: LogupAtRow<Self>,
}

Evaluates expressions at a point out of domain.

Fields

mask: TreeVec<ColumnVec<&'a Vec<SecureField>>>

evaluation_accumulator: &'a mut PointEvaluationAccumulator

col_index: Vec<usize>

denom_inverse: SecureField

logup: LogupAtRow<Self>

Implementations

impl<'a> PointEvaluator<'a>

pub fn new( mask: TreeVec<ColumnVec<&'a Vec<SecureField>>>, evaluation_accumulator: &'a mut PointEvaluationAccumulator, denom_inverse: SecureField, log_size: u32, claimed_sum: SecureField, ) -> Self

Trait Implementations

impl EvalAtRow for PointEvaluator<'_>

fn finalize_logup_batched(&mut self, batching: &Vec<usize>)

Finalize the logup by adding the constraints for the fractions, batched by the given batching. batching should contain the batch into which every logup entry should be inserted.

fn finalize_logup(&mut self)

Finalizes the row’s logup in the default way. Currently, this means no batching.

fn finalize_logup_in_pairs(&mut self)

Finalizes the row’s logup, batched in pairs. TODO(alont) Remove this once a better batching mechanism is implemented.

type F = QM31

The field type holding values of columns for the component. These are the inputs to the constraints. It might be BaseField packed types, or even SecureField, when evaluating the columns out of domain.

type EF = QM31

A field type representing the closure of F with multiplying by SecureField. Constraints usually get multiplied by SecureField values for security.

fn next_interaction_mask<const N: usize>( &mut self, interaction: usize, _offsets: [isize; N], ) -> [Self::F; N]

Returns the mask values of the given offsets for the next column in the interaction.

fn add_constraint<G>(&mut self, constraint: G)

where Self::EF: Mul<G, Output = Self::EF>,

Adds a constraint to the component.

fn combine_ef(values: [Self::F; 4]) -> Self::EF

Combines 4 base field values into a single extension field value.

fn write_logup_frac(&mut self, fraction: Fraction<Self::EF, Self::EF>)

fn next_trace_mask(&mut self) -> Self::F

Returns the next mask value for the first interaction at offset 0.

fn get_preprocessed_column(&mut self, _column: PreProcessedColumnId) -> Self::F

fn next_extension_interaction_mask<const N: usize>( &mut self, interaction: usize, offsets: [isize; N], ) -> [Self::EF; N]

Returns the extension mask values of the given offsets for the next extension degree many columns in the interaction.

fn add_intermediate(&mut self, val: Self::F) -> Self::F

Adds an intermediate value in the base field to the component and returns its value. Does nothing by default.

fn add_extension_intermediate(&mut self, val: Self::EF) -> Self::EF

Adds an intermediate value in the extension field to the component and returns its value. Does nothing by default.

fn add_to_relation<R: Relation<Self::F, Self::EF>>( &mut self, entry: RelationEntry<'_, Self::F, Self::EF, R>, )

Adds entry.values to entry.relation with entry.multiplicity for all ‘entry’ in ‘entries’, batched together. Constraint degree increases with number of batched constraints as the denominators are multiplied.