Struct concrete::plaintext::Plaintext

pub struct Plaintext {
    pub encoders: Vec<Encoder>,
    pub plaintexts: Vec<Torus>,
    pub nb_plaintexts: usize,
}

Structure describing a list of plaintext values with their respective Encoder

Attributes

• encoder - the list of the encoders (one for each plaintext)
• plaintexts - the list of plaintexts
• nb_plaintexts - the size of both lists

Fields

encoders: Vec<Encoder>

plaintexts: Vec<Torus>

nb_plaintexts: usize

Implementations

impl Plaintext

pub fn zero(nb_plaintexts: usize) -> Plaintext

Instantiate a new empty Plaintext (set to zero) of a certain size

Argument

• nb_plaintexts - the number of plaintext that would be in the Plaintext instance

Output

• a new instantiation of an empty Plaintext (set to zero) of a certain size

Example

use concrete::Plaintext;
let nb_ct: usize = 100;
let plaintexts = Plaintext::zero(nb_ct);

pub fn encode(
    messages: &[f64],
    encoder: &Encoder
) -> Result<Plaintext, CryptoAPIError>

Instantiate a new Plaintext filled with plaintexts

Argument

• messages- a list of messages as u64
• encoder- an encoder

Output

• a new instance of Plaintext containing the plaintext of each message with respect to encoder

Example

use concrete::{Encoder, Plaintext};

// create an Encoder instance where messages are in the interval [-5, 5[
let encoder = Encoder::new(-5., 5., 8, 0).unwrap();

// create a list of messages in our interval
let messages: Vec<f64> = vec![-3.2, 4.3, 0.12, -1.1, 2.78];

// create a new Plaintext instance filled with the plaintexts we want
let pt = Plaintext::encode(&messages, &encoder).unwrap();

// print the Plaintext
println!("ec = {}", pt);

pub fn decode_nth(&self, nth: usize) -> Result<f64, CryptoAPIError>

Decode one single plaintext (from the list of plaintexts in this Plaintext instance) according to its own encoder

Arguments

• nth - the index of the plaintext to decode

Output

• the decoded value as a f64

Example

use concrete::{Encoder, Plaintext};

// create an Encoder instance where messages are in the interval [-5, 5[
let encoder = Encoder::new(-5., 5., 8, 0).unwrap();

// create a list of messages in our interval
let messages: Vec<f64> = vec![-3.2, 4.3, 0.12, -1.1, 2.78];

// create a new Plaintext instance filled with the plaintexts we want
let pt = Plaintext::encode(&messages, &encoder).unwrap();

let n: usize = 2;
let m = pt.decode_nth(n).unwrap();

pub fn encode_inplace(&mut self, messages: &[f64]) -> Result<(), CryptoAPIError>

Encode several messages according to the list of Encoders in this instance

Arguments

• messages - a list of messages as f64

Example

use concrete::{Encoder, Plaintext};

// create a list of 5 Encoder instances where messages are in the interval [-5, 5[
let encoders = vec![Encoder::new(-5., 5., 8, 0).unwrap(); 5];

// create a list of messages in our interval
let messages: Vec<f64> = vec![-3.2, 4.3, 0.12, -1.1, 2.78];

// create a new Plaintext instance that can contain 5 plaintexts
let mut ec = Plaintext::zero(5);

// set the encoders
ec.set_encoders(&encoders);

// encode our messages
ec.encode_inplace(&messages);

pub fn decode(&self) -> Result<Vec<f64>, CryptoAPIError>

Decode every plaintexts in this Plaintext instance according to its list of Encoders

Example

use concrete::{Encoder, Plaintext};

// create an Encoder instance where messages are in the interval [-5, 5[
let encoder = Encoder::new(-5., 5., 8, 0).unwrap();

// create a list of messages in our interval
let messages: Vec<f64> = vec![-3.2, 4.3, 0.12, -1.1, 2.78];

// create a new Plaintext instance filled with the plaintexts we want
let mut ec = Plaintext::encode(&messages, &encoder).unwrap();

let new_msgs: Vec<f64> = ec.decode().unwrap();

pub fn set_encoders(&mut self, encoders: &[Encoder])

Set the encoder list of this instance from an input list of encoders

Argument

• encoders - a list of Encoder elements

Example

use concrete::{Encoder, Plaintext};

let nb_ct = 100;
let mut pt = Plaintext::zero(nb_ct);
let encoders = vec![Encoder::zero(); nb_ct];
// setting the encoders
pt.set_encoders(&encoders);

pub fn set_encoders_from_one(&mut self, encoder: &Encoder)

Set the encoder list of this instance from a unique input encoder

Argument

• encoder - an Encoder

Example

use concrete::{Encoder, Plaintext};

let nb_ct = 100;
let mut pt = Plaintext::zero(nb_ct);
let encoder = Encoder::zero();
// setting the encoders
pt.set_encoders_from_one(&encoder);

pub fn set_nth_encoder(&mut self, nth: usize, encoder: &Encoder)

Set the nth encoder of the encoder list of this instance from an input encoder

Argument

• encoder - an Encoder

Example

use concrete::{Encoder, Plaintext};

let nb_ct = 100;
let mut pt = Plaintext::zero(nb_ct);
let encoder_1 = Encoder::zero();
let encoder_2 = Encoder::zero();
let n: usize = 2;
// setting the encoders
pt.set_encoders_from_one(&encoder_1);
pt.set_nth_encoder(n, &encoder_2);

pub fn save(&self, path: &str) -> Result<(), Box<dyn Error>>

pub fn load(path: &str) -> Result<Plaintext, Box<dyn Error>>

Trait Implementations

impl Clone for Plaintext

fn clone(&self) -> Plaintext

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Plaintext

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Plaintext

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Plaintext

Print needed pieces of information about this instance

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

Formats the value using the given formatter.

impl PartialEq<Plaintext> for Plaintext

fn eq(&self, other: &Plaintext) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Plaintext) -> bool

This method tests for !=.

impl Serialize for Plaintext

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Plaintext