Enum ShortintBootstrappingKey 

pub enum ShortintBootstrappingKey<InputScalar>
where
    InputScalar: UnsignedInteger,
{
    Classic {
        bsk: FourierLweBootstrapKeyOwned,
        modulus_switch_noise_reduction_key: ModulusSwitchConfiguration<InputScalar>,
    },
    MultiBit {
        fourier_bsk: FourierLweMultiBitBootstrapKeyOwned,
        thread_count: ThreadCount,
        deterministic_execution: bool,
    },
}

Variants

Classic

Fields

bsk: FourierLweBootstrapKeyOwned

modulus_switch_noise_reduction_key: ModulusSwitchConfiguration<InputScalar>

MultiBit

Fields

fourier_bsk: FourierLweMultiBitBootstrapKeyOwned

thread_count: ThreadCount

deterministic_execution: bool

Implementations

impl<InputScalar> ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger,

pub fn input_lwe_dimension(&self) -> LweDimension

pub fn polynomial_size(&self) -> PolynomialSize

pub fn glwe_size(&self) -> GlweSize

pub fn decomposition_base_log(&self) -> DecompositionBaseLog

pub fn decomposition_level_count(&self) -> DecompositionLevelCount

pub fn output_lwe_dimension(&self) -> LweDimension

pub fn bootstrapping_key_size_elements(&self) -> usize

pub fn bootstrapping_key_size_bytes(&self) -> usize

pub fn deterministic_pbs_execution(&self) -> bool

Indicate whether the PBS algorithm is deterministic, i.e. will produce the same bit-exact output when run twice on the same bit-exact input.

Note: the classic PBS algorithm is always deterministic.

pub fn set_deterministic_pbs_execution( &mut self, new_deterministic_execution: bool, )

Set the choice of PBS algorithm to have the new_deterministic_execution behavior.

Note: the classic PBS algorithm is always deterministic and calling this function on a ServerKey made from super::ClassicPBSParameters is a no-op.

pub fn recompute_thread_count(&mut self)

Recomputes the number of threads required for the multi bit PBS.

It may be useful to call this function when the CPU usage is low and predictable to have a better value for the number of threads to use for the multi bit PBS.

Has not effects for other keys.

pub fn modulus_switch_configuration( &self, ) -> Option<&ModulusSwitchConfiguration<InputScalar>>

Trait Implementations

impl<InputScalar> Clone for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger + Clone,

fn clone(&self) -> ShortintBootstrappingKey<InputScalar>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<InputScalar> Debug for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger + Debug,

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

Formats the value using the given formatter.

impl<'de, InputScalar> Deserialize<'de> for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger + for<'a> Deserialize<'a>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, InputScalar> From<&'a ShortintBootstrappingKey<InputScalar>> for SerializableShortintBootstrappingKey<InputScalar, &'a [c64]>

where InputScalar: UnsignedInteger,

fn from(value: &'a ShortintBootstrappingKey<InputScalar>) -> Self

Converts to this type from the input type.

impl<InputScalar> From<SerializableShortintBootstrappingKey<InputScalar, ABox<[Complex<f64>]>>> for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger,

fn from( value: SerializableShortintBootstrappingKey<InputScalar, ABox<[c64]>>, ) -> Self

Converts to this type from the input type.

impl<InputScalar> From<ShortintBootstrappingKey<InputScalar>> for SerializableShortintBootstrappingKey<InputScalar, ABox<[c64]>>

where InputScalar: UnsignedInteger,

fn from(value: ShortintBootstrappingKey<InputScalar>) -> Self

Converts to this type from the input type.

impl<InputScalar> ParameterSetConformant for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger,

type ParameterSet = PBSConformanceParams

fn is_conformant(&self, parameter_set: &Self::ParameterSet) -> bool

impl<InputScalar> PartialEq for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger + PartialEq,

fn eq(&self, other: &ShortintBootstrappingKey<InputScalar>) -> 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<InputScalar> Serialize for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger + Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<InputScalar> Unversionize for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKey<InputScalar, ABox<[c64]>>: Unversionize + From<Self> + Into<Self>,

fn unversionize( versioned: Self::VersionedOwned, ) -> Result<Self, UnversionizeError>

Creates an object from a versioned enum, and eventually upgrades from previous variants.

impl<InputScalar> UnversionizeVec for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKey<InputScalar, ABox<[c64]>>: Unversionize + From<Self> + Into<Self>,

fn unversionize_vec( versioned: Self::VersionedVec, ) -> Result<Vec<Self>, UnversionizeError>

impl<InputScalar> Versionize for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger, Self: Clone, SerializableShortintBootstrappingKey<InputScalar, ABox<[c64]>>: VersionizeOwned + From<Self>,

type Versioned<'vers> = <SerializableShortintBootstrappingKey<InputScalar, ABox<[Complex<f64>]>> as VersionizeOwned>::VersionedOwned where InputScalar: UnsignedInteger + 'vers

The equivalent versioned type. It should have a variant for each version. It may own the underlying data or only hold a read-only reference to it.

fn versionize(&self) -> Self::Versioned<'_>

Wraps the object into a versioned enum with a variant for each version. This will use references on the underlying types if possible.

impl<InputScalar> VersionizeOwned for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKey<InputScalar, ABox<[c64]>>: VersionizeOwned + From<Self>,

type VersionedOwned = <SerializableShortintBootstrappingKey<InputScalar, ABox<[Complex<f64>]>> as VersionizeOwned>::VersionedOwned

fn versionize_owned(self) -> Self::VersionedOwned

Wraps the object into a versioned enum with a variant for each version. This will clone the underlying types.

impl<InputScalar> VersionizeSlice for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger, Self: Clone, SerializableShortintBootstrappingKey<InputScalar, ABox<[c64]>>: VersionizeOwned + From<Self>,

type VersionedSlice<'vers> = Vec<<ShortintBootstrappingKey<InputScalar> as Versionize>::Versioned<'vers>> where InputScalar: UnsignedInteger + 'vers

fn versionize_slice(slice: &[Self]) -> Self::VersionedSlice<'_>

impl<InputScalar> VersionizeVec for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKey<InputScalar, ABox<[c64]>>: VersionizeOwned + From<Self>,

type VersionedVec = Vec<<ShortintBootstrappingKey<InputScalar> as VersionizeOwned>::VersionedOwned>

fn versionize_vec(vec: Vec<Self>) -> Self::VersionedVec

impl<InputScalar> StructuralPartialEq for ShortintBootstrappingKey<InputScalar>

where InputScalar: UnsignedInteger,