Struct FloatEncoder 

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

An encoder for 64 bits floating point numbers.

Trait Implementations

impl AbstractEntity for FloatEncoder

type Kind = EncoderKind

The kind of the entity.

impl CleartextEncodingEngine<FloatEncoder, CleartextF64, Plaintext32> for DefaultEngine

Description:

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

fn encode_cleartext( &mut self, encoder: &FloatEncoder, cleartext: &CleartextF64, ) -> Result<Plaintext32, CleartextEncodingError<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 = engine.create_encoder_from(&FloatEncoderMinMaxConfig {
    min: 0.,
    max: 10.,
    nb_bit_precision: 8,
    nb_bit_padding: 1,
})?;
let cleartext: CleartextF64 = engine.create_cleartext_from(&5.)?;
let plaintext: Plaintext32 = engine.encode_cleartext(&encoder, &cleartext)?;

unsafe fn encode_cleartext_unchecked( &mut self, encoder: &FloatEncoder, cleartext: &CleartextF64, ) -> Plaintext32

Unsafely encodes a cleartext into a plaintext.

impl CleartextEncodingEngine<FloatEncoder, CleartextF64, Plaintext64> for DefaultEngine

Description:

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

fn encode_cleartext( &mut self, encoder: &FloatEncoder, cleartext: &CleartextF64, ) -> Result<Plaintext64, CleartextEncodingError<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 = engine.create_encoder_from(&FloatEncoderMinMaxConfig {
    min: 0.,
    max: 10.,
    nb_bit_precision: 8,
    nb_bit_padding: 1,
})?;
let cleartext: CleartextF64 = engine.create_cleartext_from(&5.)?;
let plaintext: Plaintext64 = engine.encode_cleartext(&encoder, &cleartext)?;

unsafe fn encode_cleartext_unchecked( &mut self, encoder: &FloatEncoder, cleartext: &CleartextF64, ) -> Plaintext64

Unsafely encodes a cleartext into a plaintext.

impl Debug for FloatEncoder

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

Formats the value using the given formatter.

impl EncoderCreationEngine<FloatEncoderCenterRadiusConfig, FloatEncoder> for DefaultEngine

Description:

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

fn create_encoder_from( &mut self, config: &FloatEncoderCenterRadiusConfig, ) -> Result<FloatEncoder, EncoderCreationError<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 = engine.create_encoder_from(&FloatEncoderCenterRadiusConfig {
    center: 10.,
    radius: 5.,
    nb_bit_precision: 8,
    nb_bit_padding: 1,
})?;

unsafe fn create_encoder_from_unchecked( &mut self, config: &FloatEncoderCenterRadiusConfig, ) -> FloatEncoder

Unsafely creates an encoder from a config.

impl EncoderCreationEngine<FloatEncoderMinMaxConfig, FloatEncoder> for DefaultEngine

Description:

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

fn create_encoder_from( &mut self, config: &FloatEncoderMinMaxConfig, ) -> Result<FloatEncoder, EncoderCreationError<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 = engine.create_encoder_from(&FloatEncoderMinMaxConfig {
    min: 0.,
    max: 10.,
    nb_bit_precision: 8,
    nb_bit_padding: 1,
})?;

unsafe fn create_encoder_from_unchecked( &mut self, config: &FloatEncoderMinMaxConfig, ) -> FloatEncoder

Unsafely creates an encoder from a config.

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

Description:

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

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

Example:

use concrete_core::prelude::{PlaintextCount, *};


// 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 = engine.create_encoder_from(&FloatEncoderMinMaxConfig {
    min: 0.,
    max: 10.,
    nb_bit_precision: 8,
    nb_bit_padding: 1,
})?;

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

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

Unsafely deserializes an entity.

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

Description:

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

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

Example:

use concrete_core::prelude::{PlaintextCount, *};


// 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 = engine.create_encoder_from(&FloatEncoderMinMaxConfig {
    min: 0.,
    max: 10.,
    nb_bit_precision: 8,
    nb_bit_padding: 1,
})?;

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

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

Unsafely serializes an entity.

impl PartialEq for FloatEncoder

fn eq(&self, other: &FloatEncoder) -> 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 PlaintextDecodingEngine<FloatEncoder, Plaintext32, CleartextF64> for DefaultEngine

Description:

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

fn decode_plaintext( &mut self, encoder: &FloatEncoder, input: &Plaintext32, ) -> Result<CleartextF64, PlaintextDecodingError<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 = engine.create_encoder_from(&FloatEncoderMinMaxConfig {
    min: 0.,
    max: 10.,
    nb_bit_precision: 8,
    nb_bit_padding: 1,
})?;
let cleartext: CleartextF64 = engine.create_cleartext_from(&5.)?;
let plaintext: Plaintext32 = engine.encode_cleartext(&encoder, &cleartext)?;
let recovered_cleartext: CleartextF64 = engine.decode_plaintext(&encoder, &plaintext)?;

unsafe fn decode_plaintext_unchecked( &mut self, input: &Plaintext32, encoder: &FloatEncoder, ) -> CleartextF64

Unsafely decodes a plaintext.

impl PlaintextDecodingEngine<FloatEncoder, Plaintext64, CleartextF64> for DefaultEngine

Description:

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

fn decode_plaintext( &mut self, encoder: &FloatEncoder, input: &Plaintext64, ) -> Result<CleartextF64, PlaintextDecodingError<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 = engine.create_encoder_from(&FloatEncoderMinMaxConfig {
    min: 0.,
    max: 10.,
    nb_bit_precision: 8,
    nb_bit_padding: 1,
})?;
let cleartext: CleartextF64 = engine.create_cleartext_from(&5.)?;
let plaintext: Plaintext64 = engine.encode_cleartext(&encoder, &cleartext)?;
let recovered_cleartext: CleartextF64 = engine.decode_plaintext(&encoder, &plaintext)?;

unsafe fn decode_plaintext_unchecked( &mut self, input: &Plaintext64, encoder: &FloatEncoder, ) -> CleartextF64

Unsafely decodes a plaintext.

impl EncoderEntity for FloatEncoder

impl StructuralPartialEq for FloatEncoder