Trait EncryptionImpl 

pub unsafe trait EncryptionImpl<BE: Backend>: Backend {
    // Required methods
    fn lwe_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: LWEInfos;
    fn lwe_encrypt_sk_default<R, P, S, E>(
        module: &Module<BE>,
        res: &mut R,
        pt: &P,
        sk: &S,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: LWEToBackendMut<BE> + LWEInfos,
             P: LWEPlaintextToBackendRef<BE>,
             S: LWESecretToBackendRef<BE>,
             E: EncryptionInfos;
    fn glwe_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GLWEInfos;
    fn glwe_encrypt_sk_default<R, P, S, E>(
        module: &Module<BE>,
        res: &mut R,
        pt: &P,
        sk: &S,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GLWEToBackendMut<BE>,
             P: GLWEToBackendRef<BE>,
             E: EncryptionInfos,
             S: GLWESecretPreparedToBackendRef<BE>;
    fn glwe_encrypt_zero_sk_default<R, E, S>(
        module: &Module<BE>,
        res: &mut R,
        sk: &S,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GLWEToBackendMut<BE>,
             E: EncryptionInfos,
             S: GLWESecretPreparedToBackendRef<BE>;
    fn glwe_encrypt_pk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GLWEInfos;
    fn glwe_encrypt_pk_default<R, P, K, E>(
        module: &Module<BE>,
        res: &mut R,
        pt: &P,
        pk: &K,
        enc_infos: &E,
        source_xu: &mut Source,
        source_xe: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GLWEToBackendMut<BE> + GLWEInfos,
             P: GLWEToBackendRef<BE> + GLWEInfos,
             E: EncryptionInfos,
             K: GLWEPreparedToBackendRef<BE> + GetDistribution + GLWEInfos;
    fn glwe_encrypt_zero_pk_default<R, K, E>(
        module: &Module<BE>,
        res: &mut R,
        pk: &K,
        enc_infos: &E,
        source_xu: &mut Source,
        source_xe: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GLWEToBackendMut<BE> + GLWEInfos,
             E: EncryptionInfos,
             K: GLWEPreparedToBackendRef<BE> + GetDistribution + GLWEInfos;
    fn glwe_public_key_generate_default<R, S, E>(
        module: &Module<BE>,
        res: &mut R,
        sk: &S,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
    )
       where R: GLWEToBackendMut<BE> + GetDistributionMut + GLWEInfos,
             E: EncryptionInfos,
             S: GLWESecretPreparedToBackendRef<BE> + GetDistribution;
    fn gglwe_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn gglwe_encrypt_sk_default<R, P, S, E>(
        module: &Module<BE>,
        res: &mut R,
        pt: &P,
        sk: &S,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWEToBackendMut<BE>,
             P: ScalarZnxToBackendRef<BE>,
             E: EncryptionInfos,
             S: GLWESecretPreparedToBackendRef<BE>;
    fn ggsw_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGSWInfos;
    fn ggsw_encrypt_sk_default<R, P, S, E>(
        module: &Module<BE>,
        res: &mut R,
        pt: &P,
        sk: &S,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGSWToBackendMut<BE> + GGSWInfos + GGSWAtViewMut<BE>,
             P: ScalarZnxToBackendRef<BE> + ZnxInfos,
             E: EncryptionInfos,
             S: GLWESecretPreparedToBackendRef<BE> + LWEInfos + GLWEInfos;
    fn gglwe_to_ggsw_key_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn gglwe_to_ggsw_key_encrypt_sk_default<R, S, E>(
        module: &Module<BE>,
        res: &mut R,
        sk: &S,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWEToGGSWKeyToBackendMut<BE>,
             E: EncryptionInfos,
             S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos;
    fn glwe_switching_key_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn glwe_switching_key_encrypt_sk_default<R, S1, S2, E>(
        module: &Module<BE>,
        res: &mut R,
        sk_in: &S1,
        sk_out: &S2,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWEToBackendMut<BE> + GLWESwitchingKeyDegreesMut + GGLWEInfos,
             E: EncryptionInfos,
             S1: GLWESecretToBackendRef<BE> + GLWEInfos,
             S2: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos;
    fn glwe_switching_key_encrypt_pk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn glwe_tensor_key_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn glwe_tensor_key_encrypt_sk_default<R, S, E>(
        module: &Module<BE>,
        res: &mut R,
        sk: &S,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWEToBackendMut<BE> + GGLWEInfos,
             E: EncryptionInfos,
             S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos;
    fn glwe_to_lwe_key_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn glwe_to_lwe_key_encrypt_sk_default<R, S1, S2, E>(
        module: &Module<BE>,
        res: &mut R,
        sk_lwe: &S1,
        sk_glwe: &S2,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where S1: LWESecretToBackendRef<BE>,
             S2: GLWESecretToBackendRef<BE>,
             E: EncryptionInfos,
             R: GGLWEToBackendMut<BE> + GGLWEInfos;
    fn lwe_switching_key_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn lwe_switching_key_encrypt_sk_default<R, S1, S2, E>(
        module: &Module<BE>,
        res: &mut R,
        sk_lwe_in: &S1,
        sk_lwe_out: &S2,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWEToBackendMut<BE> + GLWESwitchingKeyDegreesMut + GGLWEInfos,
             E: EncryptionInfos,
             S1: LWESecretToBackendRef<BE>,
             S2: LWESecretToBackendRef<BE>;
    fn lwe_to_glwe_key_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn lwe_to_glwe_key_encrypt_sk_default<R, S1, S2, E>(
        module: &Module<BE>,
        res: &mut R,
        sk_lwe: &S1,
        sk_glwe: &S2,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where S1: LWESecretToBackendRef<BE>,
             S2: GLWESecretPreparedToBackendRef<BE>,
             E: EncryptionInfos,
             R: GGLWEToBackendMut<BE> + GGLWEInfos;
    fn glwe_automorphism_key_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn glwe_automorphism_key_encrypt_sk_default<R, S, E>(
        module: &Module<BE>,
        res: &mut R,
        p: i64,
        sk: &S,
        enc_infos: &E,
        source_xe: &mut Source,
        source_xa: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWEToBackendMut<BE> + SetGaloisElement + GGLWEInfos,
             E: EncryptionInfos,
             S: GLWESecretToBackendRef<BE> + GLWEInfos;
    fn glwe_automorphism_key_encrypt_pk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn glwe_compressed_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GLWEInfos;
    fn glwe_compressed_encrypt_sk_default<R, P, S, E>(
        module: &Module<BE>,
        res: &mut R,
        pt: &P,
        sk: &S,
        seed_xa: [u8; 32],
        enc_infos: &E,
        source_xe: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GLWECompressedToBackendMut<BE> + GLWECompressedSeedMut,
             P: GLWEToBackendRef<BE>,
             E: EncryptionInfos,
             S: GLWESecretPreparedToBackendRef<BE>;
    fn gglwe_compressed_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn gglwe_compressed_encrypt_sk_default<R, P, S, E>(
        module: &Module<BE>,
        res: &mut R,
        pt: &P,
        sk: &S,
        seed: [u8; 32],
        enc_infos: &E,
        source_xe: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWECompressedToBackendMut<BE> + GGLWECompressedSeedMut,
             P: ScalarZnxToBackendRef<BE>,
             E: EncryptionInfos,
             S: GLWESecretPreparedToBackendRef<BE>;
    fn ggsw_compressed_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGSWInfos;
    fn ggsw_compressed_encrypt_sk_default<R, P, S, E>(
        module: &Module<BE>,
        res: &mut R,
        pt: &P,
        sk: &S,
        seed_xa: [u8; 32],
        enc_infos: &E,
        source_xe: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGSWCompressedToBackendMut<BE> + GGSWCompressedSeedMut + GGSWInfos,
             P: ScalarZnxToBackendRef<BE>,
             E: EncryptionInfos,
             S: GLWESecretPreparedToBackendRef<BE>;
    fn gglwe_to_ggsw_key_compressed_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn gglwe_to_ggsw_key_compressed_encrypt_sk_default<R, S, E>(
        module: &Module<BE>,
        res: &mut R,
        sk: &S,
        seed_xa: [u8; 32],
        enc_infos: &E,
        source_xe: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWEToGGSWKeyCompressedToBackendMut<BE> + GGLWEInfos,
             E: EncryptionInfos,
             S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos;
    fn glwe_automorphism_key_compressed_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn glwe_automorphism_key_compressed_encrypt_sk_default<R, S, E>(
        module: &Module<BE>,
        res: &mut R,
        p: i64,
        sk: &S,
        seed_xa: [u8; 32],
        enc_infos: &E,
        source_xe: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWECompressedToBackendMut<BE> + GGLWECompressedSeedMut + SetGaloisElement + GGLWEInfos,
             E: EncryptionInfos,
             S: GLWESecretToBackendRef<BE> + GLWEInfos;
    fn glwe_switching_key_compressed_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn glwe_switching_key_compressed_encrypt_sk_default<R, S1, S2, E>(
        module: &Module<BE>,
        res: &mut R,
        sk_in: &S1,
        sk_out: &S2,
        seed_xa: [u8; 32],
        enc_infos: &E,
        source_xe: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWECompressedToBackendMut<BE> + GGLWECompressedSeedMut + GLWESwitchingKeyDegreesMut + GGLWEInfos,
             E: EncryptionInfos,
             S1: GLWESecretToBackendRef<BE> + GLWEInfos,
             S2: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos;
    fn glwe_tensor_key_compressed_encrypt_sk_tmp_bytes_default<A>(
        module: &Module<BE>,
        infos: &A,
    ) -> usize
       where A: GGLWEInfos;
    fn glwe_tensor_key_compressed_encrypt_sk_default<R, S, E>(
        module: &Module<BE>,
        res: &mut R,
        sk: &S,
        seed_xa: [u8; 32],
        enc_infos: &E,
        source_xe: &mut Source,
        scratch: &mut ScratchArena<'_, BE>,
    )
       where R: GGLWECompressedToBackendMut<BE> + GGLWEInfos + GGLWECompressedSeedMut,
             E: EncryptionInfos,
             S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos;
}

Safety

Implementations must satisfy the contracts of all trait methods, including any HAL-level invariants (alignment, layout, scratch sizing) implied by the associated method signatures.

Required Methods

fn lwe_encrypt_sk_tmp_bytes_default<A>(module: &Module<BE>, infos: &A) -> usize

where A: LWEInfos,

fn lwe_encrypt_sk_default<R, P, S, E>( module: &Module<BE>, res: &mut R, pt: &P, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: LWEToBackendMut<BE> + LWEInfos, P: LWEPlaintextToBackendRef<BE>, S: LWESecretToBackendRef<BE>, E: EncryptionInfos,

fn glwe_encrypt_sk_tmp_bytes_default<A>(module: &Module<BE>, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_encrypt_sk_default<R, P, S, E>( module: &Module<BE>, res: &mut R, pt: &P, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>, P: GLWEToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

fn glwe_encrypt_zero_sk_default<R, E, S>( module: &Module<BE>, res: &mut R, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

fn glwe_encrypt_pk_tmp_bytes_default<A>(module: &Module<BE>, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_encrypt_pk_default<R, P, K, E>( module: &Module<BE>, res: &mut R, pt: &P, pk: &K, enc_infos: &E, source_xu: &mut Source, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, P: GLWEToBackendRef<BE> + GLWEInfos, E: EncryptionInfos, K: GLWEPreparedToBackendRef<BE> + GetDistribution + GLWEInfos,

fn glwe_encrypt_zero_pk_default<R, K, E>( module: &Module<BE>, res: &mut R, pk: &K, enc_infos: &E, source_xu: &mut Source, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, E: EncryptionInfos, K: GLWEPreparedToBackendRef<BE> + GetDistribution + GLWEInfos,

fn glwe_public_key_generate_default<R, S, E>( module: &Module<BE>, res: &mut R, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, )

where R: GLWEToBackendMut<BE> + GetDistributionMut + GLWEInfos, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE> + GetDistribution,

fn gglwe_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn gglwe_encrypt_sk_default<R, P, S, E>( module: &Module<BE>, res: &mut R, pt: &P, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE>, P: ScalarZnxToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

fn ggsw_encrypt_sk_tmp_bytes_default<A>(module: &Module<BE>, infos: &A) -> usize

where A: GGSWInfos,

fn ggsw_encrypt_sk_default<R, P, S, E>( module: &Module<BE>, res: &mut R, pt: &P, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWInfos + GGSWAtViewMut<BE>, P: ScalarZnxToBackendRef<BE> + ZnxInfos, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE> + LWEInfos + GLWEInfos,

fn gglwe_to_ggsw_key_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn gglwe_to_ggsw_key_encrypt_sk_default<R, S, E>( module: &Module<BE>, res: &mut R, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToGGSWKeyToBackendMut<BE>, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

fn glwe_switching_key_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_switching_key_encrypt_sk_default<R, S1, S2, E>( module: &Module<BE>, res: &mut R, sk_in: &S1, sk_out: &S2, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GLWESwitchingKeyDegreesMut + GGLWEInfos, E: EncryptionInfos, S1: GLWESecretToBackendRef<BE> + GLWEInfos, S2: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

fn glwe_switching_key_encrypt_pk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_tensor_key_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_tensor_key_encrypt_sk_default<R, S, E>( module: &Module<BE>, res: &mut R, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GGLWEInfos, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

fn glwe_to_lwe_key_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_to_lwe_key_encrypt_sk_default<R, S1, S2, E>( module: &Module<BE>, res: &mut R, sk_lwe: &S1, sk_glwe: &S2, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where S1: LWESecretToBackendRef<BE>, S2: GLWESecretToBackendRef<BE>, E: EncryptionInfos, R: GGLWEToBackendMut<BE> + GGLWEInfos,

fn lwe_switching_key_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn lwe_switching_key_encrypt_sk_default<R, S1, S2, E>( module: &Module<BE>, res: &mut R, sk_lwe_in: &S1, sk_lwe_out: &S2, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GLWESwitchingKeyDegreesMut + GGLWEInfos, E: EncryptionInfos, S1: LWESecretToBackendRef<BE>, S2: LWESecretToBackendRef<BE>,

fn lwe_to_glwe_key_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn lwe_to_glwe_key_encrypt_sk_default<R, S1, S2, E>( module: &Module<BE>, res: &mut R, sk_lwe: &S1, sk_glwe: &S2, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where S1: LWESecretToBackendRef<BE>, S2: GLWESecretPreparedToBackendRef<BE>, E: EncryptionInfos, R: GGLWEToBackendMut<BE> + GGLWEInfos,

fn glwe_automorphism_key_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_automorphism_key_encrypt_sk_default<R, S, E>( module: &Module<BE>, res: &mut R, p: i64, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + SetGaloisElement + GGLWEInfos, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GLWEInfos,

fn glwe_automorphism_key_encrypt_pk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_compressed_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GLWEInfos,

fn glwe_compressed_encrypt_sk_default<R, P, S, E>( module: &Module<BE>, res: &mut R, pt: &P, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWECompressedToBackendMut<BE> + GLWECompressedSeedMut, P: GLWEToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

fn gglwe_compressed_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn gglwe_compressed_encrypt_sk_default<R, P, S, E>( module: &Module<BE>, res: &mut R, pt: &P, sk: &S, seed: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWECompressedToBackendMut<BE> + GGLWECompressedSeedMut, P: ScalarZnxToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

fn ggsw_compressed_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGSWInfos,

fn ggsw_compressed_encrypt_sk_default<R, P, S, E>( module: &Module<BE>, res: &mut R, pt: &P, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWCompressedToBackendMut<BE> + GGSWCompressedSeedMut + GGSWInfos, P: ScalarZnxToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

fn gglwe_to_ggsw_key_compressed_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn gglwe_to_ggsw_key_compressed_encrypt_sk_default<R, S, E>( module: &Module<BE>, res: &mut R, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToGGSWKeyCompressedToBackendMut<BE> + GGLWEInfos, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

fn glwe_automorphism_key_compressed_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_automorphism_key_compressed_encrypt_sk_default<R, S, E>( module: &Module<BE>, res: &mut R, p: i64, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWECompressedToBackendMut<BE> + GGLWECompressedSeedMut + SetGaloisElement + GGLWEInfos, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GLWEInfos,

fn glwe_switching_key_compressed_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_switching_key_compressed_encrypt_sk_default<R, S1, S2, E>( module: &Module<BE>, res: &mut R, sk_in: &S1, sk_out: &S2, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWECompressedToBackendMut<BE> + GGLWECompressedSeedMut + GLWESwitchingKeyDegreesMut + GGLWEInfos, E: EncryptionInfos, S1: GLWESecretToBackendRef<BE> + GLWEInfos, S2: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

fn glwe_tensor_key_compressed_encrypt_sk_tmp_bytes_default<A>( module: &Module<BE>, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_tensor_key_compressed_encrypt_sk_default<R, S, E>( module: &Module<BE>, res: &mut R, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWECompressedToBackendMut<BE> + GGLWEInfos + GGLWECompressedSeedMut, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<BE: Backend> EncryptionImpl<BE> for BE

where Module<BE>: EncryptionDefault<BE>,