Struct LweKeyswitchKeyView64 

pub struct LweKeyswitchKeyView64<'a>(/* private fields */);

A structure representing an LWE keyswitch key with 64 bits of precision.

By view here, we mean that the entity does not own the data, but immutably borrows it.

Notes:

This view is not Clone as Clone for a slice is not defined. It is not Deserialize either, as Deserialize of a slice is not defined. Immutable variant.

Trait Implementations

impl AbstractEntity for LweKeyswitchKeyView64<'_>

type Kind = LweKeyswitchKeyKind

The kind of the entity.

impl<'a> Debug for LweKeyswitchKeyView64<'a>

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

Formats the value using the given formatter.

impl<'data> LweKeyswitchKeyConsumingRetrievalEngine<LweKeyswitchKeyView64<'data>, &'data [u64]> for DefaultEngine

fn consume_retrieve_lwe_keyswitch_key( &mut self, keyswitch_key: LweKeyswitchKeyView64<'data>, ) -> Result<&'data [u64], LweKeyswitchKeyConsumingRetrievalError<Self::EngineError>>

Example:

use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(6);
let output_lwe_dimension = LweDimension(3);
let decomposition_level_count = DecompositionLevelCount(2);
let decomposition_base_log = DecompositionBaseLog(8);
let noise = Variance(2_f64.powf(-50.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let owned_container = vec![
    0u64;
    input_lwe_dimension.0
        * output_lwe_dimension.to_lwe_size().0
        * decomposition_level_count.0
];
let slice = owned_container.as_slice();

let keyswitch_key: LweKeyswitchKeyView64 = engine.create_lwe_keyswitch_key_from(
    slice,
    output_lwe_dimension,
    decomposition_base_log,
    decomposition_level_count,
)?;
let retrieved_slice = engine.consume_retrieve_lwe_keyswitch_key(keyswitch_key)?;

assert_eq!(slice, retrieved_slice);

unsafe fn consume_retrieve_lwe_keyswitch_key_unchecked( &mut self, keyswitch_key: LweKeyswitchKeyView64<'data>, ) -> &'data [u64]

Unsafely retrieves the content of the container from an LWE keyswitch key, consuming it in the process.

impl<'data> LweKeyswitchKeyCreationEngine<&'data [u64], LweKeyswitchKeyView64<'data>> for DefaultEngine

fn create_lwe_keyswitch_key_from( &mut self, container: &'data [u64], output_lwe_dimension: LweDimension, decomposition_base_log: DecompositionBaseLog, decomposition_level_count: DecompositionLevelCount, ) -> Result<LweKeyswitchKeyView64<'data>, LweKeyswitchKeyCreationError<Self::EngineError>>

Example:

use concrete_core::prelude::*;

// DISCLAIMER: the parameters used here are only for test purpose, and are not secure.
let input_lwe_dimension = LweDimension(6);
let output_lwe_dimension = LweDimension(3);
let decomposition_level_count = DecompositionLevelCount(2);
let decomposition_base_log = DecompositionBaseLog(8);
let noise = Variance(2_f64.powf(-50.));

// Unix seeder must be given a secret input.
// Here we just give it 0, which is totally unsafe.
const UNSAFE_SECRET: u128 = 0;
let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
let owned_container = vec![
    0u64;
    input_lwe_dimension.0
        * output_lwe_dimension.to_lwe_size().0
        * decomposition_level_count.0
];

let keyswitch_key: LweKeyswitchKeyView64 = engine.create_lwe_keyswitch_key_from(
    owned_container.as_slice(),
    output_lwe_dimension,
    decomposition_base_log,
    decomposition_level_count,
)?;

assert_eq!(
    keyswitch_key.decomposition_level_count(),
    decomposition_level_count
);
assert_eq!(
    keyswitch_key.decomposition_base_log(),
    decomposition_base_log
);
assert_eq!(keyswitch_key.input_lwe_dimension(), input_lwe_dimension);
assert_eq!(keyswitch_key.output_lwe_dimension(), output_lwe_dimension);

unsafe fn create_lwe_keyswitch_key_from_unchecked( &mut self, container: &'data [u64], output_lwe_dimension: LweDimension, decomposition_base_log: DecompositionBaseLog, decomposition_level_count: DecompositionLevelCount, ) -> LweKeyswitchKeyView64<'data>

Unsafely creates an LWE keyswitch key from an existing container.

impl LweKeyswitchKeyEntity for LweKeyswitchKeyView64<'_>

fn input_lwe_dimension(&self) -> LweDimension

Returns the input LWE dimension of the key.

fn output_lwe_dimension(&self) -> LweDimension

Returns the output lew dimension of the key.

fn decomposition_level_count(&self) -> DecompositionLevelCount

Returns the number of decomposition levels of the key.

fn decomposition_base_log(&self) -> DecompositionBaseLog

Returns the logarithm of the base used in the key.

impl<'a> PartialEq for LweKeyswitchKeyView64<'a>

fn eq(&self, other: &LweKeyswitchKeyView64<'a>) -> 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<'a> Eq for LweKeyswitchKeyView64<'a>

impl<'a> StructuralPartialEq for LweKeyswitchKeyView64<'a>