Struct CompressedFheInt

pub struct CompressedFheInt<Id>
where
    Id: FheIntId,
{ /* private fields */ }

Available on crate feature integer only.

Compressed FheInt

Meant to save in storage space / transfer.

• A Compressed type must be decompressed using decompress before it can be used.
• It is not possible to compress an existing FheInt. compression can only be achieved at encryption time by a ClientKey

Example

use tfhe::prelude::*;
use tfhe::{generate_keys, CompressedFheInt32, ConfigBuilder};

let (client_key, _) = generate_keys(ConfigBuilder::default());
let compressed = CompressedFheInt32::encrypt(i32::MIN, &client_key);

let decompressed = compressed.decompress();
let decrypted: i32 = decompressed.decrypt(&client_key);
assert_eq!(decrypted, i32::MIN);

Implementations

impl<Id> CompressedFheInt<Id>

where Id: FheIntId,

pub fn into_raw_parts(self) -> (CompressedSignedRadixCiphertext, Id, Tag)

pub fn from_raw_parts( ciphertext: CompressedSignedRadixCiphertext, id: Id, tag: Tag, ) -> Self

impl<Id> CompressedFheInt<Id>

where Id: FheIntId,

pub fn decompress(&self) -> FheInt<Id>

Decompress to a FheInt

See CompressedFheInt example.

Trait Implementations

impl<Id> Clone for CompressedFheInt<Id>

where Id: FheIntId + Clone,

fn clone(&self) -> CompressedFheInt<Id>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de, Id> Deserialize<'de> for CompressedFheInt<Id>

where Id: FheIntId + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Id, T> FheTryEncrypt<T, ClientKey> for CompressedFheInt<Id>

where Id: FheIntId, T: DecomposableInto<u64> + SignedNumeric,

type Error = Error

fn try_encrypt(value: T, key: &ClientKey) -> Result<Self, Self::Error>

impl<Id: FheIntId> Named for CompressedFheInt<Id>

const NAME: &'static str = "high_level_api::CompressedFheInt"

Default name for the type

const BACKWARD_COMPATIBILITY_ALIASES: &'static [&'static str] = _

Aliases that should also be accepted for backward compatibility when checking the name of values of this type

impl<Id: FheIntId> ParameterSetConformant for CompressedFheInt<Id>

type ParameterSet = FheIntConformanceParams<Id>

fn is_conformant(&self, params: &FheIntConformanceParams<Id>) -> bool

impl<Id> Serialize for CompressedFheInt<Id>

where Id: FheIntId + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Id> Tagged for CompressedFheInt<Id>

where Id: FheIntId,

fn tag(&self) -> &Tag

fn tag_mut(&mut self) -> &mut Tag

impl<Id> Unversionize for CompressedFheInt<Id>

where Id: FheIntId, CompressedFheIntVersions<Id>: VersionsDispatch<Self>,

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

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

impl<Id> UnversionizeVec for CompressedFheInt<Id>

where Id: FheIntId, CompressedFheIntVersions<Id>: VersionsDispatch<Self>,

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

impl<Id: FheIntId> Upgrade<CompressedFheInt<Id>> for CompressedFheIntV0<Id>

type Error = Infallible

fn upgrade(self) -> Result<CompressedFheInt<Id>, Self::Error>

impl<Id> Version for CompressedFheInt<Id>

where Id: FheIntId + VersionizeOwned + Unversionize + Versionize, CompressedSignedRadixCiphertext: VersionizeOwned + Unversionize + Versionize, Tag: VersionizeOwned + Unversionize + Versionize,

type Ref<'vers> = CompressedFheIntVersion<'vers, Id> where Id: FheIntId + 'vers

type Owned = CompressedFheIntVersionOwned<Id>

impl<Id> Versionize for CompressedFheInt<Id>

where Id: FheIntId, CompressedFheIntVersions<Id>: VersionsDispatch<Self>,

type Versioned<'vers> = <CompressedFheIntVersions<Id> as VersionsDispatch<CompressedFheInt<Id>>>::Ref<'vers> where Id: FheIntId + '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<Id> VersionizeOwned for CompressedFheInt<Id>

where Id: FheIntId, CompressedFheIntVersions<Id>: VersionsDispatch<Self>,

type VersionedOwned = <CompressedFheIntVersions<Id> as VersionsDispatch<CompressedFheInt<Id>>>::Owned where Id: FheIntId

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<Id> VersionizeSlice for CompressedFheInt<Id>

where Id: FheIntId, CompressedFheIntVersions<Id>: VersionsDispatch<Self>,

type VersionedSlice<'vers> = Vec<<CompressedFheInt<Id> as Versionize>::Versioned<'vers>> where Id: FheIntId + 'vers

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

impl<Id> VersionizeVec for CompressedFheInt<Id>

where Id: FheIntId, CompressedFheIntVersions<Id>: VersionsDispatch<Self>,

type VersionedVec = Vec<<CompressedFheInt<Id> as VersionizeOwned>::VersionedOwned> where Id: FheIntId

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

impl<Id: FheIntId> VersionsDispatch<CompressedFheInt<Id>> for CompressedFheIntVersions<Id>

where CompressedFheIntV0<Id>: Version + Upgrade<CompressedFheInt<Id>>, CompressedFheInt<Id>: Version,

type Ref<'vers> = CompressedFheIntVersionsDispatch<'vers, Id> where Id: 'vers

type Owned = CompressedFheIntVersionsDispatchOwned<Id>