Struct CompressedCiphertextList 

pub struct CompressedCiphertextList { /* private fields */ }

Implementations

impl CompressedCiphertextList

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn get_kind_of(&self, index: usize) -> Option<DataKind>

pub fn get<T>( &self, index: usize, decomp_key: &DecompressionKey, ) -> Result<Option<T>>

where T: Expandable,

pub fn get_decompression_size_on_gpu( &self, index: usize, decomp_key: &CudaDecompressionKey, streams: &CudaStreams, ) -> Option<u64>

impl CompressedCiphertextList

pub fn to_cuda_compressed_ciphertext_list( &self, streams: &CudaStreams, ) -> CudaCompressedCiphertextList

 use tfhe::core_crypto::gpu::CudaStreams;
 use tfhe::integer::ciphertext::CompressedCiphertextListBuilder;
 use tfhe::integer::gpu::ciphertext::boolean_value::CudaBooleanBlock;
 use tfhe::integer::gpu::ciphertext::{CudaSignedRadixCiphertext, CudaUnsignedRadixCiphertext};
 use tfhe::integer::gpu::gen_keys_radix_gpu;
 use tfhe::shortint::parameters::{
     COMP_PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128,
     PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128,
 };

 let block_params = PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128;
 let compression_params =
     COMP_PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128;
 let num_blocks = 32;
 let streams = CudaStreams::new_multi_gpu();

 let (radix_cks, _) = gen_keys_radix_gpu(block_params, num_blocks, &streams);
 let cks = radix_cks.as_ref();

 let private_compression_key = cks.new_compression_private_key(compression_params);

 let (compressed_compression_key, compressed_decompression_key) =
     radix_cks.new_compressed_compression_decompression_keys(&private_compression_key);

 let cuda_decompression_key = compressed_decompression_key.decompress_to_cuda(
     radix_cks.parameters().glwe_dimension(),
     radix_cks.parameters().polynomial_size(),
     radix_cks.parameters().message_modulus(),
     radix_cks.parameters().carry_modulus(),
     radix_cks.parameters().ciphertext_modulus(),
     &streams,
 );

 let compression_key = compressed_compression_key.decompress();

 let ct1 = radix_cks.encrypt(3_u32);
 let ct2 = radix_cks.encrypt_signed(-2);
 let ct3 = radix_cks.encrypt_bool(true);

 let compressed = CompressedCiphertextListBuilder::new()
     .push(ct1)
     .push(ct2)
     .push(ct3)
     .build(&compression_key);

 let cuda_compressed = compressed.to_cuda_compressed_ciphertext_list(&streams);
 let recovered_cuda_compressed = cuda_compressed.to_compressed_ciphertext_list(&streams);

 assert_eq!(recovered_cuda_compressed, compressed);

 let d_decompressed1: CudaUnsignedRadixCiphertext = cuda_compressed
     .get(0, &cuda_decompression_key, &streams)
     .unwrap()
     .unwrap();
 let decompressed1 = d_decompressed1.to_radix_ciphertext(&streams);
 let decrypted: u32 = radix_cks.decrypt(&decompressed1);
 assert_eq!(decrypted, 3_u32);

 let d_decompressed2: CudaSignedRadixCiphertext = cuda_compressed
     .get(1, &cuda_decompression_key, &streams)
     .unwrap()
     .unwrap();
 let decompressed2 = d_decompressed2.to_signed_radix_ciphertext(&streams);
 let decrypted: i32 = radix_cks.decrypt_signed(&decompressed2);
 assert_eq!(decrypted, -2);

 let d_decompressed3: CudaBooleanBlock = cuda_compressed
     .get(2, &cuda_decompression_key, &streams)
     .unwrap()
     .unwrap();
 let decompressed3 = d_decompressed3.to_boolean_block(&streams);
 let decrypted = radix_cks.decrypt_bool(&decompressed3);
 assert!(decrypted);

Trait Implementations

impl Clone for CompressedCiphertextList

fn clone(&self) -> CompressedCiphertextList

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompressedCiphertextList

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompressedCiphertextList

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CompressedCiphertextList

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Unversionize for CompressedCiphertextList

where CompressedCiphertextListVersions: VersionsDispatch<Self>,

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

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

impl UnversionizeVec for CompressedCiphertextList

where CompressedCiphertextListVersions: VersionsDispatch<Self>,

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

impl Version for CompressedCiphertextList

where ShortintCompressedCiphertextList: VersionizeOwned + Unversionize + Versionize, Vec<DataKind>: VersionizeOwned + Unversionize + Versionize,

type Ref<'vers> = CompressedCiphertextListVersion<'vers>

type Owned = CompressedCiphertextListVersionOwned

impl Versionize for CompressedCiphertextList

where CompressedCiphertextListVersions: VersionsDispatch<Self>,

type Versioned<'vers> = <CompressedCiphertextListVersions as VersionsDispatch<CompressedCiphertextList>>::Ref<'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 VersionizeOwned for CompressedCiphertextList

where CompressedCiphertextListVersions: VersionsDispatch<Self>,

type VersionedOwned = <CompressedCiphertextListVersions as VersionsDispatch<CompressedCiphertextList>>::Owned

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 VersionizeSlice for CompressedCiphertextList

where CompressedCiphertextListVersions: VersionsDispatch<Self>,

type VersionedSlice<'vers> = Vec<<CompressedCiphertextList as Versionize>::Versioned<'vers>>

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

impl VersionizeVec for CompressedCiphertextList

where CompressedCiphertextListVersions: VersionsDispatch<Self>,

type VersionedVec = Vec<<CompressedCiphertextList as VersionizeOwned>::VersionedOwned>

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

impl VersionsDispatch<CompressedCiphertextList> for CompressedCiphertextListVersions

where CompressedCiphertextList: Version,

type Ref<'vers> = CompressedCiphertextListVersionsDispatch<'vers>

type Owned = CompressedCiphertextListVersionsDispatchOwned

impl Eq for CompressedCiphertextList

impl StructuralPartialEq for CompressedCiphertextList