[−][src]Trait concrete_lib::operators::math::tensor::Tensor

pub trait Tensor: Sized {
    fn named_print(slice: &[Self], s: String);

    fn uniform_random_default(res: &mut [Self]);

    fn uniform_random_with_some_zeros(res: &mut [Self], probability: f64);

    fn normal_random_default(res: &mut [Self], mean: f64, std_dev: f64);

    fn get_normal_random_default(mean: f64, std_dev: f64) -> Self;

    fn add(res: &mut [Self], t0: &[Self], t1: &[Self]);

    fn add_inplace(res: &mut [Self], t: &[Self]);

    fn neg_inplace(res: &mut [Self]);

    fn sub(res: &mut [Self], t0: &[Self], t1: &[Self]);

    fn sub_inplace(res: &mut [Self], t: &[Self]);

    fn scalar_mul(res: &mut [Self], t_in: &[Self], n: Self);

    fn scalar_mul_inplace(t_in: &mut [Self], n: Self);

    fn sub_scalar_mul(res: &mut [Self], t_in: &[Self], n: Self);

    fn add_scalar_mul(res: &mut [Self], t_in: &[Self], n: Self);

    fn binary_multisum(t_torus: &[Self], t_bool: &[Self]) -> Self;

    fn add_several_binary_multisum(
        t_res: &mut [Self], 
        t_torus: &[Self], 
        t_bool: &[Self]
    );

    fn get_binary_multisum(t_torus: &[Self], t_bool: &[Self]) -> Self;

    fn sub_several_binary_multisum(
        t_res: &mut [Self], 
        t_torus: &[Self], 
        t_bool: &[Self]
    );

    fn round_to_closest_multiple(
        t_res: &mut [Self], 
        t_input: &[Self], 
        base_log: usize, 
        max_level: usize
    );

    fn int_to_float(t_res: &mut [f64], t_int: &[Self]);

    fn float_to_int(t_res: &mut [Self], t_float: &[f64]);

    fn compute_modular_distance(t_res: &mut [Self], t_x: &[Self], t_y: &[Self]);

    fn compute_signed_modular_distance(
        t_res: &mut [f64], 
        t_x: &[Self], 
        t_y: &[Self]
    );

    fn print(tensor: &[Self]);

    fn write_in_file(tensor: &[Self], path: &str) -> Result<()>;

    fn read_in_file(tensor: &mut [Self], path: &str) -> Result<()>;

    fn to_string_torus_binary_representation(
        tensor: &[Self], 
        base_log: usize
    ) -> String;
}

Required methods

fn named_print(slice: &[Self], s: String)

fn uniform_random_default(res: &mut [Self])

fn uniform_random_with_some_zeros(res: &mut [Self], probability: f64)

fn normal_random_default(res: &mut [Self], mean: f64, std_dev: f64)

fn get_normal_random_default(mean: f64, std_dev: f64) -> Self

fn add(res: &mut [Self], t0: &[Self], t1: &[Self])

fn add_inplace(res: &mut [Self], t: &[Self])

fn neg_inplace(res: &mut [Self])

fn sub(res: &mut [Self], t0: &[Self], t1: &[Self])

fn sub_inplace(res: &mut [Self], t: &[Self])

fn scalar_mul(res: &mut [Self], t_in: &[Self], n: Self)

fn scalar_mul_inplace(t_in: &mut [Self], n: Self)

fn sub_scalar_mul(res: &mut [Self], t_in: &[Self], n: Self)

fn add_scalar_mul(res: &mut [Self], t_in: &[Self], n: Self)

fn binary_multisum(t_torus: &[Self], t_bool: &[Self]) -> Self

fn add_several_binary_multisum(
    t_res: &mut [Self],
    t_torus: &[Self],
    t_bool: &[Self]
)

fn get_binary_multisum(t_torus: &[Self], t_bool: &[Self]) -> Self

fn sub_several_binary_multisum(
    t_res: &mut [Self],
    t_torus: &[Self],
    t_bool: &[Self]
)

fn round_to_closest_multiple(
    t_res: &mut [Self],
    t_input: &[Self],
    base_log: usize,
    max_level: usize
)

fn int_to_float(t_res: &mut [f64], t_int: &[Self])

fn float_to_int(t_res: &mut [Self], t_float: &[f64])

fn compute_modular_distance(t_res: &mut [Self], t_x: &[Self], t_y: &[Self])

fn compute_signed_modular_distance(
    t_res: &mut [f64],
    t_x: &[Self],
    t_y: &[Self]
)

fn print(tensor: &[Self])

fn write_in_file(tensor: &[Self], path: &str) -> Result<()>

fn read_in_file(tensor: &mut [Self], path: &str) -> Result<()>

fn to_string_torus_binary_representation(
    tensor: &[Self],
    base_log: usize
) -> String

Loading content...

Implementations on Foreign Types

impl Tensor for u32[src]

fn named_print(slice: &[u32], s: String)[src]

Prints a slice Arguments

  • slice - the slice to print
  • s - a prefix string printed before the slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 6;

// creation of a tensor
let mut t: Vec<Torus> = vec![0; size];
Tensor::uniform_random_default(&mut t);

// print
Tensor::named_print(&t, "a cool name".to_string());

// stdout:
// [a cool name] tensor = [583243732, 2345345062, 1029325848, 2822984367, 1059378147, 607021394, ]

fn neg_inplace(res: &mut [u32])[src]

Fill res with the opposite of res (in the torus)

Description

res <- - res

Arguments

  • res - Torus slice (output)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// neg
Tensor::neg_inplace(&mut t);

fn uniform_random_default(res: &mut [u32])[src]

Fills res with uniformly random values from the default source

Description

res <- uniform random

Arguments

  • res - Torus slice (output)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 6;

// creation of a tensor
let mut t: Vec<Torus> = vec![0; size];
Tensor::uniform_random_default(&mut t);

fn uniform_random_with_some_zeros(res: &mut [u32], probability: f64)[src]

Either fills elements of res with uniform random or with a zero according to probability if probability is set to 0.2, then there will be approximately 1/5 random elements and the rest will be set to zero

Arguments

  • res - Torus slice (output)
  • probability - the probability for an element to be uniformly random

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 15;

// creation of a tensor
let mut t: Vec<Torus> = vec![0; size];
Tensor::uniform_random_with_some_zeros(&mut t, 0.2);

// print
Tensor::named_print(&t, "80 percents of zeros".to_string());

// stdout:
// [80 percents of zeros] tensor = [0, 0, 0, 0, 2085785791, 0, 0, 0, 607256796, 0, 195350706, 0, 0, 0, 0, ]

fn normal_random_default(res: &mut [u32], mean: f64, std_dev: f64)[src]

Fill res with normal random values

Description

res <- normal_random(mean,std_dev)

Arguments

  • res - Torus slice (output)
  • mean - mean of the normal distribution
  • std_dev - standard deviation of the normal distribution

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 6;

// creation of a tensor
let mut t: Vec<Torus> = vec![0; size];
Tensor::normal_random_default(&mut t, 0., 0.00003);

fn get_normal_random_default(mean: f64, std_dev: f64) -> u32[src]

Fill res with normal random values

Arguments

  • mean - mean of the normal distribution
  • std_dev - standard deviation of the normal distribution

Output

  • return a sample drawn from a normal distribution with the given hyper-parameters(mean,std_dev)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 6;

// draw a random sample
let a: Torus = Tensor::get_normal_random_default(0., 0.00003);

fn add(res: &mut [u32], t0: &[u32], t1: &[u32])[src]

Fill res with the sum of t0 and t1 (in the torus)

Description

res <- t0 + t1

Arguments

  • res - Torus slice (output)
  • t0 - Torus slice
  • t1 - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// allocation of a tensor for the result
let mut res: Vec<Torus> = vec![0; size];

// add
Tensor::add(&mut res, &t0, &t1);

fn add_inplace(res: &mut [u32], t: &[u32])[src]

Fill res with the sum of res and t0 (in the torus)

Description

res <- res + t

Arguments

  • res - Torus slice (output)
  • t- Torus sclice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// add
Tensor::add_inplace(&mut t0, &t1);

fn sub(res: &mut [u32], t0: &[u32], t1: &[u32])[src]

Fill res with t0 minus t1 (in the torus)

Description

res <- t0 - t1

Arguments

  • res - Torus slice (output)
  • t0 - Torus slice
  • t1 - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// allocation of a tensor for the result
let mut res: Vec<Torus> = vec![0; size];

// subtract
Tensor::sub(&mut res, &t0, &t1);

fn sub_inplace(res: &mut [u32], t: &[u32])[src]

Fill res with res minus t0 (in the torus)

Description

res <- res - t0

Arguments

  • res - Torus slice (output)
  • t - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// subtract
Tensor::sub_inplace(&mut t0, &t1);

fn scalar_mul(res: &mut [u32], t_in: &[u32], n: u32)[src]

Multiply res by a scalar n

Description

res <- tin * n

Arguments

  • res - Torus slice (output)
  • t_in - Torus slice
  • n - integer (u32 or u64)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// select a scalar
let scal: Torus = 12;

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// scalar multiplication
Tensor::scalar_mul(&mut res, &t, scal);

fn scalar_mul_inplace(t_in: &mut [u32], n: u32)[src]

Multiply res by n, a signed integer

Description

tin <- tin * n

Arguments

  • t_in - Torus slice (output)
  • n - integer (u32 or u64)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// select a scalar
let scal: Torus = 12;

// scalar multiplication
Tensor::scalar_mul_inplace(&mut t, scal);

fn sub_scalar_mul(res: &mut [u32], t_in: &[u32], n: u32)[src]

Subtract to res the multiplication of t_in by a scalar n

Description

res <- res - t_in * n

Arguments

  • res - Torus slice (output)
  • t_in - Torus slice
  • n - integer (u32 or u64)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// select a scalar
let scal: Torus = 12;

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// subtract the scalar multiplication
Tensor::sub_scalar_mul(&mut res, &t, scal);

fn add_scalar_mul(res: &mut [u32], t_in: &[u32], n: u32)[src]

Add to res the multiplication of t_in by a scalar n

Description

res <- res + t_in * n

Arguments

  • res - Torus slice (output)
  • t_in - Torus slice
  • n - integer (u32 or u64)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// select a scalar
let scal: Torus = 12;

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// add the scalar multiplication
Tensor::add_scalar_mul(&mut res, &t, scal);

fn binary_multisum(t_torus: &[u32], t_bool: &[u32]) -> u32[src]

Compute the torus-boolean scalar product

Description

t_torus <- sum_i(t_torus[i] * t_bool[i])

Arguments

  • t_torus - Torus slice
  • t_bool - Torus slice representing an array of booleans

Output

  • a Torus element containing the desired result

Example

use concrete_lib::operators::crypto::SecretKey;
use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of a binary torus
let mut tb: Vec<Torus> = vec![0; <Torus as SecretKey>::get_secret_key_length(size, 1)];

// ... (fill the last tensor)

// compute a binary multisum
let res: Torus = Tensor::binary_multisum(&t, &tb);

fn add_several_binary_multisum(
    t_res: &mut [u32],
    t_torus: &[u32],
    t_bool: &[u32]
)[src]

Takes as input n vectors of Torus element in t_torus, computes every inner product between the i-th Torus vector and the boolean vector t_bool, and adds that value to the i-th case of t_res

Description

t_res[j] <- t_res[j] + sum_i(t_torus[j][i] * t_bool[i])

Arguments

  • t_res - Torus slice (output)
  • t_torus - Torus slice
  • t_bool - Torus slice representing a boolean slice

Example

use concrete_lib::operators::crypto::SecretKey;
use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of a binary torus
let mut tb: Vec<Torus> = vec![0; <Torus as SecretKey>::get_secret_key_length(size, 1)];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// add several binary multisum
Tensor::add_several_binary_multisum(&mut res, &t, &tb);

fn get_binary_multisum(t_torus: &[u32], t_bool: &[u32]) -> u32[src]

Takes as input a vector of Torus element in t_torus, computes the inner product between the Torus vector and the boolean vector t_bool, and return it

Description

return sum_i(t_torus[j][i] * t_bool[i])

Arguments

  • t_torus - Torus slice
  • t_bool - Torus slice representing a boolean slice

Example

use concrete_lib::operators::crypto::SecretKey;
use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of a binary torus
let mut tb: Vec<Torus> = vec![0; <Torus as SecretKey>::get_secret_key_length(size, 1)];

// ... (fill the last tensor)


// get the binary multisum
let res: Torus = Tensor::get_binary_multisum(&t, &tb);

fn sub_several_binary_multisum(
    t_res: &mut [u32],
    t_torus: &[u32],
    t_bool: &[u32]
)[src]

Takes as input n vectors of Torus element in t_torus, computes every inner product between the i-th Torus vector and the boolean vector t_bool, and subtracts that value to the i-th case of t_res

Description

t_res[j] <- t_res[j] - sum_i(t_torus[j][i] * t_bool[i])

Arguments

  • t_res - Torus slice (output)
  • t_torus - Torus slice
  • t_bool - Torus slice representing a boolean slice

Example

use concrete_lib::operators::crypto::SecretKey;
use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of a binary torus
let mut tb: Vec<Torus> = vec![0; <Torus as SecretKey>::get_secret_key_length(size, 1)];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// subtract several binary multisum
Tensor::sub_several_binary_multisum(&mut res, &t, &tb);

fn round_to_closest_multiple(
    t_res: &mut [u32],
    t_input: &[u32],
    base_log: usize,
    max_level: usize
)[src]

Rounds each element of a Torus slice to the max_level * base_log bit

Warning

  • this function panics if TORUS_BIT == max_level * base_log

Arguments

  • t_res - Torus slice (output)
  • t_input - Torus slice
  • base_log - the number of bit of the basis for the decomposition
  • max_level - the total number of levels

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;
let base_log: usize = 2;
let max_level: usize = 4;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// rounding
Tensor::round_to_closest_multiple(&mut res, &t, base_log, max_level);

fn int_to_float(t_res: &mut [f64], t_int: &[u32])[src]

Convert a Torus tensor into a float tensor

Description

t_res <- (float) t_int

Arguments

  • t_res - float slice (output)
  • t_int - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<f64> = vec![0.; size];

// convert
Tensor::int_to_float(&mut res, &t);

fn float_to_int(t_res: &mut [u32], t_float: &[f64])[src]

Convert a float tensor into a torus tensor

Description

t_res <- (Torus) t_float

Arguments

  • t_res - Torus slice (output)
  • t_float - float slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<f64> = vec![0.; size];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// convert
Tensor::float_to_int(&mut res, &t);

fn compute_modular_distance(t_res: &mut [u32], t_x: &[u32], t_y: &[u32])[src]

Computes the minimal modular distance element wise between two slices of torus elements The result is stored in t_res

Arguments

  • t_res - torus slice (output)
  • t_x - torus slice
  • t_y - torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last tensors)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// convert
Tensor::compute_modular_distance(&mut res, &t0, &t1);

fn compute_signed_modular_distance(t_res: &mut [f64], t_x: &[u32], t_y: &[u32])[src]

Computes a signed modular distance element wise between two slices of torus elements The result is stored in t_res

Arguments

  • t_res - float slice (output)
  • t_x - torus slice
  • t_y - torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last tensors)

// allocation of the result
let mut res: Vec<f64> = vec![0.; size];

// convert
Tensor::compute_signed_modular_distance(&mut res, &t0, &t1);

fn print(tensor: &[u32])[src]

Prints in a pretty way a tensor of Torus elements

Arguments

  • tensor - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 4;

// allocation of a tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensors)

// print
Tensor::print(&t);

// stdout:
// [TENSOR] val: 0 0 0 0

fn write_in_file(tensor: &[u32], path: &str) -> Result<()>[src]

Writes in a compact way a tensor of Torus elements inside a file

Arguments

  • tensor - Torus slice
  • path - string containing the path of the file we write in

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// setting
let size: usize = 128;

// create a tensor
let mut tensor: Vec<Torus> = vec![0; size];

// ... (fill the tensor)

// writes in a file
Tensor::write_in_file(&tensor, "test_read_write_torus.txt");

fn read_in_file(tensor: &mut [u32], path: &str) -> Result<()>[src]

Reads in a compact way a tensor of Torus elements inside a file

Arguments

  • tensor - Torus slice (output)
  • path - string containing the path of the file we read in

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// setting
let size: usize = 128;

// create a tensor
let mut tensor: Vec<Torus> = vec![0; size];

// reads in a file
Tensor::read_in_file(&mut tensor, "test_read_write_torus.txt");

fn to_string_torus_binary_representation(
    tensor: &[u32],
    base_log: usize
) -> String[src]

Generate a pretty string representing a tensor of Torus elements with their binary representations base_log defines the size of the bit blocks in the binary representation

Arguments

  • tensor - Torus slice
  • base_log - size of bit blocks in the binary representation

Example

use concrete_lib::operators::math::Tensor;
type Torus = u32;

// settings
let size: usize = 4;

// allocation of a tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensors)

// print
let s = Tensor::to_string_torus_binary_representation(&t, 4);

// s = "0000 0000 0000 0000 0000 0000 0000 0000:0000 0000 0000 0000 0000 0000 0000 0000:0000 0000 0000 0000 0000 0000 0000 0000:0000 0000 0000 0000 0000 0000 0000 0000:"

impl Tensor for u64[src]

fn named_print(slice: &[u64], s: String)[src]

Prints a slice Arguments

  • slice - the slice to print
  • s - a prefix string printed before the slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 6;

// creation of a tensor
let mut t: Vec<Torus> = vec![0; size];
Tensor::uniform_random_default(&mut t);

// print
Tensor::named_print(&t, "a cool name".to_string());

// stdout:
// [a cool name] tensor = [583243732, 2345345062, 1029325848, 2822984367, 1059378147, 607021394, ]

fn neg_inplace(res: &mut [u64])[src]

Fill res with the opposite of res (in the torus)

Description

res <- - res

Arguments

  • res - Torus slice (output)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// neg
Tensor::neg_inplace(&mut t);

fn uniform_random_default(res: &mut [u64])[src]

Fills res with uniformly random values from the default source

Description

res <- uniform random

Arguments

  • res - Torus slice (output)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 6;

// creation of a tensor
let mut t: Vec<Torus> = vec![0; size];
Tensor::uniform_random_default(&mut t);

fn uniform_random_with_some_zeros(res: &mut [u64], probability: f64)[src]

Either fills elements of res with uniform random or with a zero according to probability if probability is set to 0.2, then there will be approximately 1/5 random elements and the rest will be set to zero

Arguments

  • res - Torus slice (output)
  • probability - the probability for an element to be uniformly random

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 15;

// creation of a tensor
let mut t: Vec<Torus> = vec![0; size];
Tensor::uniform_random_with_some_zeros(&mut t, 0.2);

// print
Tensor::named_print(&t, "80 percents of zeros".to_string());

// stdout:
// [80 percents of zeros] tensor = [0, 0, 0, 0, 2085785791, 0, 0, 0, 607256796, 0, 195350706, 0, 0, 0, 0, ]

fn normal_random_default(res: &mut [u64], mean: f64, std_dev: f64)[src]

Fill res with normal random values

Description

res <- normal_random(mean,std_dev)

Arguments

  • res - Torus slice (output)
  • mean - mean of the normal distribution
  • std_dev - standard deviation of the normal distribution

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 6;

// creation of a tensor
let mut t: Vec<Torus> = vec![0; size];
Tensor::normal_random_default(&mut t, 0., 0.00003);

fn get_normal_random_default(mean: f64, std_dev: f64) -> u64[src]

Fill res with normal random values

Arguments

  • mean - mean of the normal distribution
  • std_dev - standard deviation of the normal distribution

Output

  • return a sample drawn from a normal distribution with the given hyper-parameters(mean,std_dev)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 6;

// draw a random sample
let a: Torus = Tensor::get_normal_random_default(0., 0.00003);

fn add(res: &mut [u64], t0: &[u64], t1: &[u64])[src]

Fill res with the sum of t0 and t1 (in the torus)

Description

res <- t0 + t1

Arguments

  • res - Torus slice (output)
  • t0 - Torus slice
  • t1 - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// allocation of a tensor for the result
let mut res: Vec<Torus> = vec![0; size];

// add
Tensor::add(&mut res, &t0, &t1);

fn add_inplace(res: &mut [u64], t: &[u64])[src]

Fill res with the sum of res and t0 (in the torus)

Description

res <- res + t

Arguments

  • res - Torus slice (output)
  • t- Torus sclice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// add
Tensor::add_inplace(&mut t0, &t1);

fn sub(res: &mut [u64], t0: &[u64], t1: &[u64])[src]

Fill res with t0 minus t1 (in the torus)

Description

res <- t0 - t1

Arguments

  • res - Torus slice (output)
  • t0 - Torus slice
  • t1 - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// allocation of a tensor for the result
let mut res: Vec<Torus> = vec![0; size];

// subtract
Tensor::sub(&mut res, &t0, &t1);

fn sub_inplace(res: &mut [u64], t: &[u64])[src]

Fill res with res minus t0 (in the torus)

Description

res <- res - t0

Arguments

  • res - Torus slice (output)
  • t - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last two tensors)

// subtract
Tensor::sub_inplace(&mut t0, &t1);

fn scalar_mul(res: &mut [u64], t_in: &[u64], n: u64)[src]

Multiply res by a scalar n

Description

res <- tin * n

Arguments

  • res - Torus slice (output)
  • t_in - Torus slice
  • n - integer (u32 or u64)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// select a scalar
let scal: Torus = 12;

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// scalar multiplication
Tensor::scalar_mul(&mut res, &t, scal);

fn scalar_mul_inplace(t_in: &mut [u64], n: u64)[src]

Multiply res by n, a signed integer

Description

tin <- tin * n

Arguments

  • t_in - Torus slice (output)
  • n - integer (u32 or u64)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// select a scalar
let scal: Torus = 12;

// scalar multiplication
Tensor::scalar_mul_inplace(&mut t, scal);

fn sub_scalar_mul(res: &mut [u64], t_in: &[u64], n: u64)[src]

Subtract to res the multiplication of t_in by a scalar n

Description

res <- res - t_in * n

Arguments

  • res - Torus slice (output)
  • t_in - Torus slice
  • n - integer (u32 or u64)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// select a scalar
let scal: Torus = 12;

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// subtract the scalar multiplication
Tensor::sub_scalar_mul(&mut res, &t, scal);

fn add_scalar_mul(res: &mut [u64], t_in: &[u64], n: u64)[src]

Add to res the multiplication of t_in by a scalar n

Description

res <- res + t_in * n

Arguments

  • res - Torus slice (output)
  • t_in - Torus slice
  • n - integer (u32 or u64)

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// select a scalar
let scal: Torus = 12;

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// add the scalar multiplication
Tensor::add_scalar_mul(&mut res, &t, scal);

fn binary_multisum(t_torus: &[u64], t_bool: &[u64]) -> u64[src]

Compute the torus-boolean scalar product

Description

t_torus <- sum_i(t_torus[i] * t_bool[i])

Arguments

  • t_torus - Torus slice
  • t_bool - Torus slice representing an array of booleans

Output

  • a Torus element containing the desired result

Example

use concrete_lib::operators::crypto::SecretKey;
use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of a binary torus
let mut tb: Vec<Torus> = vec![0; <Torus as SecretKey>::get_secret_key_length(size, 1)];

// ... (fill the last tensor)

// compute a binary multisum
let res: Torus = Tensor::binary_multisum(&t, &tb);

fn add_several_binary_multisum(
    t_res: &mut [u64],
    t_torus: &[u64],
    t_bool: &[u64]
)[src]

Takes as input n vectors of Torus element in t_torus, computes every inner product between the i-th Torus vector and the boolean vector t_bool, and adds that value to the i-th case of t_res

Description

t_res[j] <- t_res[j] + sum_i(t_torus[j][i] * t_bool[i])

Arguments

  • t_res - Torus slice (output)
  • t_torus - Torus slice
  • t_bool - Torus slice representing a boolean slice

Example

use concrete_lib::operators::crypto::SecretKey;
use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of a binary torus
let mut tb: Vec<Torus> = vec![0; <Torus as SecretKey>::get_secret_key_length(size, 1)];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// add several binary multisum
Tensor::add_several_binary_multisum(&mut res, &t, &tb);

fn get_binary_multisum(t_torus: &[u64], t_bool: &[u64]) -> u64[src]

Takes as input a vector of Torus element in t_torus, computes the inner product between the Torus vector and the boolean vector t_bool, and return it

Description

return sum_i(t_torus[j][i] * t_bool[i])

Arguments

  • t_torus - Torus slice
  • t_bool - Torus slice representing a boolean slice

Example

use concrete_lib::operators::crypto::SecretKey;
use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of a binary torus
let mut tb: Vec<Torus> = vec![0; <Torus as SecretKey>::get_secret_key_length(size, 1)];

// ... (fill the last tensor)


// get the binary multisum
let res: Torus = Tensor::get_binary_multisum(&t, &tb);

fn sub_several_binary_multisum(
    t_res: &mut [u64],
    t_torus: &[u64],
    t_bool: &[u64]
)[src]

Takes as input n vectors of Torus element in t_torus, computes every inner product between the i-th Torus vector and the boolean vector t_bool, and subtracts that value to the i-th case of t_res

Description

t_res[j] <- t_res[j] - sum_i(t_torus[j][i] * t_bool[i])

Arguments

  • t_res - Torus slice (output)
  • t_torus - Torus slice
  • t_bool - Torus slice representing a boolean slice

Example

use concrete_lib::operators::crypto::SecretKey;
use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of a binary torus
let mut tb: Vec<Torus> = vec![0; <Torus as SecretKey>::get_secret_key_length(size, 1)];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// subtract several binary multisum
Tensor::sub_several_binary_multisum(&mut res, &t, &tb);

fn round_to_closest_multiple(
    t_res: &mut [u64],
    t_input: &[u64],
    base_log: usize,
    max_level: usize
)[src]

Rounds each element of a Torus slice to the max_level * base_log bit

Warning

  • this function panics if TORUS_BIT == max_level * base_log

Arguments

  • t_res - Torus slice (output)
  • t_input - Torus slice
  • base_log - the number of bit of the basis for the decomposition
  • max_level - the total number of levels

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;
let base_log: usize = 2;
let max_level: usize = 4;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// rounding
Tensor::round_to_closest_multiple(&mut res, &t, base_log, max_level);

fn int_to_float(t_res: &mut [f64], t_int: &[u64])[src]

Convert a Torus tensor into a float tensor

Description

t_res <- (float) t_int

Arguments

  • t_res - float slice (output)
  • t_int - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<f64> = vec![0.; size];

// convert
Tensor::int_to_float(&mut res, &t);

fn float_to_int(t_res: &mut [u64], t_float: &[f64])[src]

Convert a float tensor into a torus tensor

Description

t_res <- (Torus) t_float

Arguments

  • t_res - Torus slice (output)
  • t_float - float slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of one tensor
let mut t: Vec<f64> = vec![0.; size];

// ... (fill the last tensor)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// convert
Tensor::float_to_int(&mut res, &t);

fn compute_modular_distance(t_res: &mut [u64], t_x: &[u64], t_y: &[u64])[src]

Computes the minimal modular distance element wise between two slices of torus elements The result is stored in t_res

Arguments

  • t_res - torus slice (output)
  • t_x - torus slice
  • t_y - torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last tensors)

// allocation of the result
let mut res: Vec<Torus> = vec![0; size];

// convert
Tensor::compute_modular_distance(&mut res, &t0, &t1);

fn compute_signed_modular_distance(t_res: &mut [f64], t_x: &[u64], t_y: &[u64])[src]

Computes a signed modular distance element wise between two slices of torus elements The result is stored in t_res

Arguments

  • t_res - float slice (output)
  • t_x - torus slice
  • t_y - torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 100;

// allocation of two tensors
let mut t0: Vec<Torus> = vec![0; size];
let mut t1: Vec<Torus> = vec![0; size];

// ... (fill the last tensors)

// allocation of the result
let mut res: Vec<f64> = vec![0.; size];

// convert
Tensor::compute_signed_modular_distance(&mut res, &t0, &t1);

fn print(tensor: &[u64])[src]

Prints in a pretty way a tensor of Torus elements

Arguments

  • tensor - Torus slice

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 4;

// allocation of a tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensors)

// print
Tensor::print(&t);

// stdout:
// [TENSOR] val: 0 0 0 0

fn write_in_file(tensor: &[u64], path: &str) -> Result<()>[src]

Writes in a compact way a tensor of Torus elements inside a file

Arguments

  • tensor - Torus slice
  • path - string containing the path of the file we write in

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// setting
let size: usize = 128;

// create a tensor
let mut tensor: Vec<Torus> = vec![0; size];

// ... (fill the tensor)

// writes in a file
Tensor::write_in_file(&tensor, "test_read_write_torus.txt");

fn read_in_file(tensor: &mut [u64], path: &str) -> Result<()>[src]

Reads in a compact way a tensor of Torus elements inside a file

Arguments

  • tensor - Torus slice (output)
  • path - string containing the path of the file we read in

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// setting
let size: usize = 128;

// create a tensor
let mut tensor: Vec<Torus> = vec![0; size];

// reads in a file
Tensor::read_in_file(&mut tensor, "test_read_write_torus.txt");

fn to_string_torus_binary_representation(
    tensor: &[u64],
    base_log: usize
) -> String[src]

Generate a pretty string representing a tensor of Torus elements with their binary representations base_log defines the size of the bit blocks in the binary representation

Arguments

  • tensor - Torus slice
  • base_log - size of bit blocks in the binary representation

Example

use concrete_lib::operators::math::Tensor;
type Torus = u64;

// settings
let size: usize = 4;

// allocation of a tensor
let mut t: Vec<Torus> = vec![0; size];

// ... (fill the last tensors)

// print
let s = Tensor::to_string_torus_binary_representation(&t, 4);

// s = "0000 0000 0000 0000 0000 0000 0000 0000:0000 0000 0000 0000 0000 0000 0000 0000:0000 0000 0000 0000 0000 0000 0000 0000:0000 0000 0000 0000 0000 0000 0000 0000:"
Loading content...

Implementors

Loading content...