Enum Boolean

pub enum Boolean {
    Is(AllocatedBit),
    Not(AllocatedBit),
    Constant(bool),
}

This is a boolean value which may be either a constant or an interpretation of an AllocatedBit.

Variants

Is(AllocatedBit)

Existential view of the boolean variable

Not(AllocatedBit)

Negated view of the boolean variable

Constant(bool)

Constant (not an allocated variable)

Implementations

impl Boolean

pub fn is_constant(&self) -> bool

pub fn zero() -> Self

pub fn get_variable(&self) -> Option<&AllocatedBit>

pub fn alloc<E: Engine, CS: ConstraintSystem<E>>( cs: &mut CS, witness: Option<bool>, ) -> Result<Self, SynthesisError>

pub fn enforce_equal<E, CS>( cs: &mut CS, a: &Self, b: &Self, ) -> Result<(), SynthesisError>

where E: Engine, CS: ConstraintSystem<E>,

pub fn get_constant_value(&self) -> bool

pub fn get_value(&self) -> Option<bool>

pub fn get_value_in_field<E: Engine>(&self) -> Option<E::Fr>

pub fn lc<E: Engine>(&self, coeff: E::Fr) -> LinearCombination<E>

pub fn constant(b: bool) -> Self

Construct a boolean from a known constant

pub fn not(&self) -> Self

Return a negated interpretation of this boolean.

pub fn xor<'a, E, CS>( cs: &mut CS, a: &'a Self, b: &'a Self, ) -> Result<Self, SynthesisError>

where E: Engine, CS: ConstraintSystem<E>,

Perform XOR over two boolean operands

pub fn and<'a, E, CS>( cs: &mut CS, a: &'a Self, b: &'a Self, ) -> Result<Self, SynthesisError>

where E: Engine, CS: ConstraintSystem<E>,

Perform AND over two boolean operands

pub fn or<'a, E, CS>( cs: &mut CS, a: &'a Self, b: &'a Self, ) -> Result<Self, SynthesisError>

where E: Engine, CS: ConstraintSystem<E>,

Perform OR over two boolean operands

pub fn conditionally_select<E: Engine, CS: ConstraintSystem<E>>( cs: &mut CS, flag: &Self, a: &Self, b: &Self, ) -> Result<Self, SynthesisError>

pub fn sha256_ch<'a, E, CS>( cs: &mut CS, a: &'a Self, b: &'a Self, c: &'a Self, ) -> Result<Self, SynthesisError>

where E: Engine, CS: ConstraintSystem<E>,

Computes (a and b) xor ((not a) and c)

pub fn sha256_maj<'a, E, CS>( cs: &mut CS, a: &'a Self, b: &'a Self, c: &'a Self, ) -> Result<Self, SynthesisError>

where E: Engine, CS: ConstraintSystem<E>,

Computes (a and b) xor (a and c) xor (b and c)

pub fn alloc_multiple<E: Engine, CS: ConstraintSystem<E>, const N: usize>( cs: &mut CS, witness: Option<[bool; N]>, ) -> Result<[Self; N], SynthesisError>

pub fn get_value_multiple<const N: usize>(els: &[Self; N]) -> Option<[bool; N]>

pub fn conditionally_select_multiple<E: Engine, CS: ConstraintSystem<E>, const N: usize>( cs: &mut CS, flag: &Boolean, a: &[Self; N], b: &[Self; N], ) -> Result<[Self; N], SynthesisError>

Trait Implementations

impl Clone for Boolean

fn clone(&self) -> Boolean

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Boolean

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

Formats the value using the given formatter.

impl Default for Boolean

fn default() -> Self

Returns the “default value” for a type.

impl From<AllocatedBit> for Boolean

fn from(b: AllocatedBit) -> Boolean

Converts to this type from the input type.

impl<E: Engine> From<Boolean> for Num<E>

fn from(b: Boolean) -> Num<E>

Converts to this type from the input type.

impl<E: Engine> IntoBytes<E> for Boolean

fn into_le_bytes<CS: ConstraintSystem<E>>( &self, cs: &mut CS, ) -> Result<Vec<Byte<E>>, SynthesisError>

fn into_be_bytes<CS: ConstraintSystem<E>>( &self, cs: &mut CS, ) -> Result<Vec<Byte<E>>, SynthesisError>

fn encoding_len() -> usize

impl Copy for Boolean