Struct FloatEncoderVector 

pub struct FloatEncoderVector(/* private fields */);

An encoder for 64 bits floating point numbers.

Trait Implementations

impl AbstractEntity for FloatEncoderVector

type Kind = EncoderVectorKind

The kind of the entity.

impl CleartextVectorEncodingEngine<FloatEncoderVector, CleartextVectorF64, PlaintextVector32> for DefaultEngine

Description:

Implementation of CleartextVectorEncodingEngine for DefaultEngine that encodes 64 bits floating point numbers to 32 bits integers.

fn encode_cleartext_vector( &mut self, encoder_vector: &FloatEncoderVector, cleartext_vector: &CleartextVectorF64, ) -> Result<PlaintextVector32, CleartextVectorEncodingError<Self::EngineError>>

Example:

use concrete_core::prelude::*;
// 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 encoder_vector = engine.create_encoder_vector_from(&vec![
    FloatEncoderMinMaxConfig {
        min: 0.,
        max: 10.,
        nb_bit_precision: 8,
        nb_bit_padding: 1,
    };
    100
])?;
let cleartext_vector: CleartextVectorF64 =
    engine.create_cleartext_vector_from(&vec![5.; 100])?;
let plaintext_vector: PlaintextVector32 =
    engine.encode_cleartext_vector(&encoder_vector, &cleartext_vector)?;
assert_eq!(
    cleartext_vector.cleartext_count().0,
    plaintext_vector.plaintext_count().0
);

unsafe fn encode_cleartext_vector_unchecked( &mut self, encoder_vector: &FloatEncoderVector, cleartext_vector: &CleartextVectorF64, ) -> PlaintextVector32

Unsafely encodes a cleartext vector into a plaintext vector.

impl CleartextVectorEncodingEngine<FloatEncoderVector, CleartextVectorF64, PlaintextVector64> for DefaultEngine

Description:

Implementation of CleartextVectorEncodingEngine for DefaultEngine that encodes 64 bits floating point numbers to 64 bits integers.

fn encode_cleartext_vector( &mut self, encoder_vector: &FloatEncoderVector, cleartext_vector: &CleartextVectorF64, ) -> Result<PlaintextVector64, CleartextVectorEncodingError<Self::EngineError>>

Example:

use concrete_core::prelude::*;
// 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 encoder_vector = engine.create_encoder_vector_from(&vec![
    FloatEncoderMinMaxConfig {
        min: 0.,
        max: 10.,
        nb_bit_precision: 8,
        nb_bit_padding: 1,
    };
    100
])?;
let cleartext_vector: CleartextVectorF64 =
    engine.create_cleartext_vector_from(&vec![5.; 100])?;
let plaintext_vector: PlaintextVector64 =
    engine.encode_cleartext_vector(&encoder_vector, &cleartext_vector)?;
assert_eq!(
    cleartext_vector.cleartext_count().0,
    plaintext_vector.plaintext_count().0
);

unsafe fn encode_cleartext_vector_unchecked( &mut self, encoder_vector: &FloatEncoderVector, cleartext_vector: &CleartextVectorF64, ) -> PlaintextVector64

Unsafely encodes a cleartext vector into a plaintext vector.

impl Debug for FloatEncoderVector

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

Formats the value using the given formatter.

impl EncoderVectorCreationEngine<FloatEncoderCenterRadiusConfig, FloatEncoderVector> for DefaultEngine

Description:

Implementation of EncoderVectorCreationEngine for DefaultEngine that creates an encoder vector to encode vectors of 64 bits floating point numbers.

fn create_encoder_vector_from( &mut self, config: &[FloatEncoderCenterRadiusConfig], ) -> Result<FloatEncoderVector, EncoderVectorCreationError<Self::EngineError>>

Example:

use concrete_core::prelude::*;
// 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 encoder_vector = engine.create_encoder_vector_from(&vec![
    FloatEncoderCenterRadiusConfig {
        center: 10.,
        radius: 5.,
        nb_bit_precision: 8,
        nb_bit_padding: 1,
    };
    1
])?;

unsafe fn create_encoder_vector_from_unchecked( &mut self, config: &[FloatEncoderCenterRadiusConfig], ) -> FloatEncoderVector

Unsafely creates an encoder vector from a config.

impl EncoderVectorCreationEngine<FloatEncoderMinMaxConfig, FloatEncoderVector> for DefaultEngine

Description:

Implementation of EncoderVectorCreationEngine for DefaultEngine that creates an encoder vector to encode vectors of 64 bits floating point numbers.

fn create_encoder_vector_from( &mut self, config: &[FloatEncoderMinMaxConfig], ) -> Result<FloatEncoderVector, EncoderVectorCreationError<Self::EngineError>>

Example:

use concrete_core::prelude::*;
// 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 encoder_vector = engine.create_encoder_vector_from(
    vec![
        FloatEncoderMinMaxConfig {
            min: 0.,
            max: 10.,
            nb_bit_precision: 8,
            nb_bit_padding: 1,
        };
        1
    ]
    .as_slice(),
)?;

unsafe fn create_encoder_vector_from_unchecked( &mut self, config: &[FloatEncoderMinMaxConfig], ) -> FloatEncoderVector

Unsafely creates an encoder vector from a config.

impl EncoderVectorEntity for FloatEncoderVector

fn encoder_count(&self) -> EncoderCount

Returns the number of encoder contained in the vector.

impl EntityDeserializationEngine<&[u8], FloatEncoderVector> for DefaultSerializationEngine

Description:

Implementation of EntityDeserializationEngine for DefaultSerializationEngine that operates on 64 bits integers. It deserializes a float encoder vector entity.

fn deserialize( &mut self, serialized: &[u8], ) -> Result<FloatEncoderVector, EntityDeserializationError<Self::EngineError>>

Example:

use concrete_core::prelude::PlaintextCount;
use concrete_core::prelude::*;


// 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 encoder_vector = engine.create_encoder_vector_from(&vec![
    FloatEncoderCenterRadiusConfig {
        center: 10.,
        radius: 5.,
        nb_bit_precision: 8,
        nb_bit_padding: 1,
    };
    1
])?;

let mut serialization_engine = DefaultSerializationEngine::new(())?;
let serialized = serialization_engine.serialize(&encoder_vector)?;
let recovered = serialization_engine.deserialize(serialized.as_slice())?;
assert_eq!(encoder_vector, recovered);

unsafe fn deserialize_unchecked( &mut self, serialized: &[u8], ) -> FloatEncoderVector

Unsafely deserializes an entity.

impl EntitySerializationEngine<FloatEncoderVector, Vec<u8>> for DefaultSerializationEngine

Description:

Implementation of EntitySerializationEngine for DefaultSerializationEngine that operates on 64 bits integers. It serializes a float encoder vector entity.

fn serialize( &mut self, entity: &FloatEncoderVector, ) -> Result<Vec<u8>, EntitySerializationError<Self::EngineError>>

Example:

use concrete_core::prelude::PlaintextCount;
use concrete_core::prelude::*;


// 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 encoder_vector = engine.create_encoder_vector_from(&vec![
    FloatEncoderCenterRadiusConfig {
        center: 10.,
        radius: 5.,
        nb_bit_precision: 8,
        nb_bit_padding: 1,
    };
    1
])?;

let mut serialization_engine = DefaultSerializationEngine::new(())?;
let serialized = serialization_engine.serialize(&encoder_vector)?;
let recovered = serialization_engine.deserialize(serialized.as_slice())?;
assert_eq!(encoder_vector, recovered);

unsafe fn serialize_unchecked(&mut self, entity: &FloatEncoderVector) -> Vec<u8>

Unsafely serializes an entity.

impl PartialEq for FloatEncoderVector

fn eq(&self, other: &FloatEncoderVector) -> 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 PlaintextVectorDecodingEngine<FloatEncoderVector, PlaintextVector32, CleartextVectorF64> for DefaultEngine

Description:

Implementation of PlaintextVectorDecodingEngine for DefaultEngine that decodes 32 bits integers to 64 bits floating point numbers.

fn decode_plaintext_vector( &mut self, encoder: &FloatEncoderVector, input: &PlaintextVector32, ) -> Result<CleartextVectorF64, PlaintextVectorDecodingError<Self::EngineError>>

Example:

use concrete_core::prelude::*;
// 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 encoder_vector = engine.create_encoder_vector_from(&vec![
    FloatEncoderMinMaxConfig {
        min: 0.,
        max: 10.,
        nb_bit_precision: 8,
        nb_bit_padding: 1,
    };
    100
])?;
let cleartext_vector: CleartextVectorF64 =
    engine.create_cleartext_vector_from(&vec![5.; 100])?;
let plaintext_vector: PlaintextVector32 =
    engine.encode_cleartext_vector(&encoder_vector, &cleartext_vector)?;
let recovered_cleartext_vector: CleartextVectorF64 =
    engine.decode_plaintext_vector(&encoder_vector, &plaintext_vector)?;
assert_eq!(
    recovered_cleartext_vector.cleartext_count().0,
    plaintext_vector.plaintext_count().0
);

unsafe fn decode_plaintext_vector_unchecked( &mut self, encoder: &FloatEncoderVector, input: &PlaintextVector32, ) -> CleartextVectorF64

Unsafely decodes a plaintext vector.

impl PlaintextVectorDecodingEngine<FloatEncoderVector, PlaintextVector64, CleartextVectorF64> for DefaultEngine

Description:

Implementation of PlaintextVectorDecodingEngine for DefaultEngine that decodes 64 bits integers to 64 bits floating point numbers.

fn decode_plaintext_vector( &mut self, encoder: &FloatEncoderVector, input: &PlaintextVector64, ) -> Result<CleartextVectorF64, PlaintextVectorDecodingError<Self::EngineError>>

Example:

use concrete_core::prelude::*;
// 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 encoder_vector = engine.create_encoder_vector_from(&vec![
    FloatEncoderMinMaxConfig {
        min: 0.,
        max: 10.,
        nb_bit_precision: 8,
        nb_bit_padding: 1,
    };
    100
])?;
let cleartext_vector: CleartextVectorF64 =
    engine.create_cleartext_vector_from(&vec![5.; 100])?;
let plaintext_vector: PlaintextVector32 =
    engine.encode_cleartext_vector(&encoder_vector, &cleartext_vector)?;
let recovered_cleartext_vector: CleartextVectorF64 =
    engine.decode_plaintext_vector(&encoder_vector, &plaintext_vector)?;
assert_eq!(
    recovered_cleartext_vector.cleartext_count().0,
    plaintext_vector.plaintext_count().0
);

unsafe fn decode_plaintext_vector_unchecked( &mut self, encoder: &FloatEncoderVector, input: &PlaintextVector64, ) -> CleartextVectorF64

Unsafely decodes a plaintext vector.

impl StructuralPartialEq for FloatEncoderVector