Enum SerializableShortintBootstrappingKey 

pub enum SerializableShortintBootstrappingKey<InputScalar, C: Container<Element = c64>>
where
    InputScalar: UnsignedInteger,
{
    Classic {
        bsk: FourierLweBootstrapKey<C>,
        modulus_switch_noise_reduction_key: ModulusSwitchConfiguration<InputScalar>,
    },
    MultiBit {
        fourier_bsk: FourierLweMultiBitBootstrapKey<C>,
        deterministic_execution: bool,
    },
}

Variants

Classic

Fields

bsk: FourierLweBootstrapKey<C>

modulus_switch_noise_reduction_key: ModulusSwitchConfiguration<InputScalar>

MultiBit

Fields

fourier_bsk: FourierLweMultiBitBootstrapKey<C>

deterministic_execution: bool

Implementations

impl<InputScalar, C: Container<Element = c64>> SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger,

pub fn is_classic(&self) -> bool

Returns true if the serializable shortint bootstrapping key is Classic.

Trait Implementations

impl<InputScalar, C: Clone + Container<Element = c64>> Clone for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger + Clone,

fn clone(&self) -> SerializableShortintBootstrappingKey<InputScalar, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<InputScalar, C: Debug + Container<Element = c64>> Debug for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger + Debug,

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

Formats the value using the given formatter.

impl<'de, InputScalar, C> Deserialize<'de> for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger + for<'a> Deserialize<'a>, C: IntoContainerOwned + Container<Element = c64>,

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, C> Serialize for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger + Serialize, C: Serialize + Container<Element = c64>,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<InputScalar, C: Container<Element = c64>> Unversionize for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKeyVersions<InputScalar, C>: VersionsDispatch<Self>,

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

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

impl<InputScalar, C: Container<Element = c64>> UnversionizeVec for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKeyVersions<InputScalar, C>: VersionsDispatch<Self>,

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

impl<InputScalar, C: Container<Element = c64>> Upgrade<SerializableShortintBootstrappingKey<InputScalar, C>> for SerializableShortintBootstrappingKeyV1<InputScalar, C>

where InputScalar: UnsignedInteger,

type Error = Infallible

fn upgrade( self, ) -> Result<SerializableShortintBootstrappingKey<InputScalar, C>, Self::Error>

impl<InputScalar, C: Container<Element = c64>> Version for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger, FourierLweBootstrapKey<C>: VersionizeOwned + Unversionize + Versionize, ModulusSwitchConfiguration<InputScalar>: VersionizeOwned + Unversionize + Versionize, FourierLweMultiBitBootstrapKey<C>: VersionizeOwned + Unversionize + Versionize, bool: VersionizeOwned + Unversionize + Versionize,

type Ref<'vers> = SerializableShortintBootstrappingKeyVersion<'vers, InputScalar, C> where InputScalar: UnsignedInteger + 'vers, C: 'vers

type Owned = SerializableShortintBootstrappingKeyVersionOwned<InputScalar, C>

impl<InputScalar, C: Container<Element = c64>> Versionize for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKeyVersions<InputScalar, C>: VersionsDispatch<Self>,

type Versioned<'vers> = <SerializableShortintBootstrappingKeyVersions<InputScalar, C> as VersionsDispatch<SerializableShortintBootstrappingKey<InputScalar, C>>>::Ref<'vers> where InputScalar: UnsignedInteger + 'vers, C: '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, C: Container<Element = c64>> VersionizeOwned for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKeyVersions<InputScalar, C>: VersionsDispatch<Self>,

type VersionedOwned = <SerializableShortintBootstrappingKeyVersions<InputScalar, C> as VersionsDispatch<SerializableShortintBootstrappingKey<InputScalar, C>>>::Owned where InputScalar: UnsignedInteger

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, C: Container<Element = c64>> VersionizeSlice for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKeyVersions<InputScalar, C>: VersionsDispatch<Self>,

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

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

impl<InputScalar, C: Container<Element = c64>> VersionizeVec for SerializableShortintBootstrappingKey<InputScalar, C>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKeyVersions<InputScalar, C>: VersionsDispatch<Self>,

type VersionedVec = Vec<<SerializableShortintBootstrappingKey<InputScalar, C> as VersionizeOwned>::VersionedOwned> where InputScalar: UnsignedInteger

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

impl<InputScalar, C: Container<Element = c64>> VersionsDispatch<SerializableShortintBootstrappingKey<InputScalar, C>> for SerializableShortintBootstrappingKeyVersions<InputScalar, C>

where InputScalar: UnsignedInteger, SerializableShortintBootstrappingKeyV0<C>: Version + Upgrade<SerializableShortintBootstrappingKeyV1<InputScalar, C>>, SerializableShortintBootstrappingKeyV1<InputScalar, C>: Version + Upgrade<SerializableShortintBootstrappingKey<InputScalar, C>>, SerializableShortintBootstrappingKey<InputScalar, C>: Version,

type Ref<'vers> = SerializableShortintBootstrappingKeyVersionsDispatch<'vers, InputScalar, C> where InputScalar: UnsignedInteger + 'vers, C: 'vers

type Owned = SerializableShortintBootstrappingKeyVersionsDispatchOwned<InputScalar, C>