Enum snarkvm_wasm::traits::utilities::boolean::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 get_value(&self) -> Option<bool>

pub fn lc<F>(&self, one: Variable, coeff: F) -> LinearCombination<F> where
    F: Field, 

pub fn constant_u8_vec<F, CS>(
    cs: &mut CS,
    values: &[u8]
) -> Vec<Boolean, Global> where
    CS: ConstraintSystem<F>,
    F: Field, 

Construct a boolean vector from a vector of u8

pub fn constant(b: bool) -> Boolean

Construct a boolean from a known constant.

pub fn not(&self) -> Boolean

Return a negated interpretation of this boolean.

pub fn or<F, CS>(
    cs: CS,
    a: &'a Boolean,
    b: &'a Boolean
) -> Result<Boolean, SynthesisError> where
    CS: ConstraintSystem<F>,
    F: Field, 

Perform OR over two boolean operands.

pub fn and<F, CS>(
    cs: CS,
    a: &'a Boolean,
    b: &'a Boolean
) -> Result<Boolean, SynthesisError> where
    CS: ConstraintSystem<F>,
    F: Field, 

Perform AND over two boolean operands.

pub fn kary_and<F, CS>(
    cs: CS,
    bits: &[Boolean]
) -> Result<Boolean, SynthesisError> where
    CS: ConstraintSystem<F>,
    F: Field, 

Perform AND over all the given boolean operands.

pub fn enforce_nand<F, CS>(
    cs: CS,
    bits: &[Boolean]
) -> Result<(), SynthesisError> where
    CS: ConstraintSystem<F>,
    F: Field, 

Asserts that at least one operand is false.

pub fn enforce_in_field<F, CS, NativeF>(
    cs: CS,
    bits: &[Boolean]
) -> Result<(), SynthesisError> where
    CS: ConstraintSystem<F>,
    F: Field,
    NativeF: PrimeField, 

Asserts that this bit_gadget representation is “in the field” when interpreted in big endian.

pub fn kary_nand<F, CS>(
    cs: CS,
    bits: &[Boolean]
) -> Result<Boolean, SynthesisError> where
    CS: ConstraintSystem<F>,
    F: Field, 

pub fn enforce_smaller_or_equal_than_le<F, CS>(
    cs: CS,
    bits: &[Boolean],
    element: impl AsRef<[u64]>
) -> Result<Vec<Boolean, Global>, SynthesisError> where
    CS: ConstraintSystem<F>,
    F: Field, 

pub fn enforce_smaller_or_equal_than_be<F, CS>(
    cs: CS,
    bits: &[Boolean],
    element: impl AsRef<[u64]>
) -> Result<Vec<Boolean, Global>, SynthesisError> where
    CS: ConstraintSystem<F>,
    F: Field, 

Trait Implementations

impl<F> AllocGadget<bool, F> for Boolean where
    F: Field, 

pub fn alloc<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Boolean, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<bool>, 

pub fn alloc_input<Fn, T, CS>(
    cs: CS,
    value_gen: Fn
) -> Result<Boolean, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<bool>, 

pub fn alloc_constant<Fn, T, CS>(
    _cs: CS,
    _f: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<V>, 

pub fn alloc_checked<Fn, T, CS>(cs: CS, f: Fn) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<V>, 

pub fn alloc_input_checked<Fn, T, CS>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    CS: ConstraintSystem<F>,
    T: Borrow<V>, 

impl Clone for Boolean

pub fn clone(&self) -> Boolean

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F> CondSelectGadget<F> for Boolean where
    F: PrimeField, 

pub fn conditionally_select<CS>(
    cs: CS,
    cond: &Boolean,
    first: &Boolean,
    second: &Boolean
) -> Result<Boolean, SynthesisError> where
    CS: ConstraintSystem<F>, 

pub fn cost() -> usize

impl<F> ConditionalEqGadget<F> for Boolean where
    F: Field, 

pub fn conditional_enforce_equal<CS>(
    &self,
    cs: CS,
    other: &Boolean,
    condition: &Boolean
) -> Result<(), SynthesisError> where
    CS: ConstraintSystem<F>, 

pub fn cost() -> usize

impl Copy for Boolean

impl Debug for Boolean

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

Formats the value using the given formatter.

impl Eq for Boolean

impl<F> EqGadget<F> for Boolean where
    F: Field, 

pub fn enforce_equal<CS>(
    &self,
    cs: CS,
    other: &Self
) -> Result<(), SynthesisError> where
    CS: ConstraintSystem<F>, 

pub fn cost() -> usize

impl<F> EvaluateEqGadget<F> for Boolean where
    F: PrimeField, 

a == b = !(a XOR b)

pub fn evaluate_equal<CS>(
    &self,
    cs: CS,
    other: &Boolean
) -> Result<Boolean, SynthesisError> where
    CS: ConstraintSystem<F>, 

impl From<AllocatedBit> for Boolean

pub fn from(b: AllocatedBit) -> Boolean

Performs the conversion.

impl<'a, F> FullAdder<'a, F> for Boolean where
    F: Field, 

pub fn add<CS>(
    cs: CS,
    a: &'a Boolean,
    b: &'a Boolean,
    carry: &'a Boolean
) -> Result<(Boolean, Boolean), SynthesisError> where
    CS: ConstraintSystem<F>, 

impl PartialEq<Boolean> for Boolean

pub fn eq(&self, other: &Boolean) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl SignExtend for Boolean

pub fn sign_extend(bits: &[Boolean], length: usize) -> Vec<Boolean, Global>

impl<F> ToBitsBEGadget<F> for Boolean where
    F: Field, 

pub fn to_bits_be<CS>(&self, CS) -> Result<Vec<Boolean, Global>, SynthesisError> where
    CS: ConstraintSystem<F>, 

pub fn to_bits_be_strict<CS>(
    &self,
    CS
) -> Result<Vec<Boolean, Global>, SynthesisError> where
    CS: ConstraintSystem<F>, 

Additionally checks if the produced list of booleans is ‘valid’.

impl<F> ToBitsLEGadget<F> for Boolean where
    F: Field, 

pub fn to_bits_le<CS>(&self, CS) -> Result<Vec<Boolean, Global>, SynthesisError> where
    CS: ConstraintSystem<F>, 

pub fn to_bits_le_strict<CS>(
    &self,
    CS
) -> Result<Vec<Boolean, Global>, SynthesisError> where
    CS: ConstraintSystem<F>, 

Additionally checks if the produced list of booleans is ‘valid’.

impl<F> ToBytesGadget<F> for Boolean where
    F: Field, 

pub fn to_bytes<CS>(
    &self,
    _cs: CS
) -> Result<Vec<UInt8, Global>, SynthesisError> where
    CS: ConstraintSystem<F>, 

pub fn to_bytes_strict<CS>(
    &self,
    cs: CS
) -> Result<Vec<UInt8, Global>, SynthesisError> where
    CS: ConstraintSystem<F>, 

Additionally checks if the produced list of booleans is ‘valid’.

impl<F> Xor<F, Boolean> for Boolean where
    F: Field, 

pub fn xor<CS>(
    &self,
    cs: CS,
    other: &Boolean
) -> Result<Boolean, SynthesisError> where
    CS: ConstraintSystem<F>,