Struct concrete::GenericShortInt

source · [−]
pub struct GenericShortInt<P: ShortIntegerParameter> { /* private fields */ }
Available on crate feature shortints only.
Expand description

A Generic short FHE unsigned integer

Short means less than 7 bits.

It is generic over some parameters, as its the parameters that controls how many bit they represent.

Its the type that overloads the operators (+, -, *). Since the GenericShortInt type is not Copy the operators are also overloaded to work with references.

You will need to use one of this type specialization (e.g., FheUint2, FheUint3, FheUint4).

To be able to use this type, the cargo feature shortints must be enabled, and your config should also enable the type with either default parameters or custom ones.

Example

To use FheUint2

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};

// Enable the FheUint2 type in the config
let config = ConfigBuilder::all_disabled().enable_default_uint2().build();

// With the FheUint2 type enabled in the config, the needed keys and details
// can be taken care of.
let (client_key, server_key) = generate_keys(config);

let a = FheUint2::try_encrypt(0, &client_key)?;
let b = FheUint2::try_encrypt(1, &client_key)?;

// Do not forget to set the server key before doing any computation
set_server_key(server_key);

// Since FHE types are bigger than native rust type they are not `Copy`,
// meaning that to reuse the same value in a computation and avoid the cost
// of calling `clone`, you'll have to use references:
let c = a + &b;
// `a` was moved but not `b`, so `a` cannot be reused, but `b` can
let d = &c + b;
// `b` was moved but not `c`, so `b` cannot be reused, but `c` can
let fhe_result = d + c;
// both `d` and `c` were moved.

let expected: u8 = {
    let a = 0;
    let b = 1;

    let c = a + b;
    let d = c + b;
    d + c
};
let clear_result = fhe_result.decrypt(&client_key);
assert_eq!(expected, 3);
assert_eq!(clear_result, expected);

Implementations

Minimum value this type can hold, always 0.

Maximum value this type can hold.

Trait Implementations

The resulting type after applying the + operator.
Performs the + operation. Read more
The resulting type after applying the + operator.
Performs the + operation. Read more

Allows using the + operator between a &GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a + b;
let decrypted = c.decrypt(&keys);
let expected = 2 + 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a + &b;
let decrypted = c.decrypt(&keys);
let expected = 2 + 1;
assert_eq!(decrypted, expected);
The resulting type after applying the + operator.
Performs the + operation. Read more

Allows using the + operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a + b;
let decrypted = c.decrypt(&keys);
let expected = 2 + 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a + &b;
let decrypted = c.decrypt(&keys);
let expected = 2 + 1;
assert_eq!(decrypted, expected);
The resulting type after applying the + operator.
Performs the + operation. Read more
The resulting type after applying the + operator.
Performs the + operation. Read more
The resulting type after applying the + operator.
Performs the + operation. Read more

Allows using the += operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a += b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected += 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a += &b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected += 1;
assert_eq!(decrypted, expected);
Performs the += operation. Read more
Performs the += operation. Read more

Allows using the & operator between a &GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a & b;
let decrypted = c.decrypt(&keys);
let expected = 2 & 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a & &b;
let decrypted = c.decrypt(&keys);
let expected = 2 & 1;
assert_eq!(decrypted, expected);
The resulting type after applying the & operator.
Performs the & operation. Read more

Allows using the & operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a & b;
let decrypted = c.decrypt(&keys);
let expected = 2 & 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a & &b;
let decrypted = c.decrypt(&keys);
let expected = 2 & 1;
assert_eq!(decrypted, expected);
The resulting type after applying the & operator.
Performs the & operation. Read more

Allows using the &= operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a &= b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected &= 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a &= &b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected &= 1;
assert_eq!(decrypted, expected);
Performs the &= operation. Read more

Allows using the | operator between a &GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a | b;
let decrypted = c.decrypt(&keys);
let expected = 2 | 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a | &b;
let decrypted = c.decrypt(&keys);
let expected = 2 | 1;
assert_eq!(decrypted, expected);
The resulting type after applying the | operator.
Performs the | operation. Read more

Allows using the | operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a | b;
let decrypted = c.decrypt(&keys);
let expected = 2 | 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a | &b;
let decrypted = c.decrypt(&keys);
let expected = 2 | 1;
assert_eq!(decrypted, expected);
The resulting type after applying the | operator.
Performs the | operation. Read more

Allows using the |= operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a |= b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected |= 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a |= &b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected |= 1;
assert_eq!(decrypted, expected);
Performs the |= operation. Read more

Allows using the ^ operator between a &GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a ^ b;
let decrypted = c.decrypt(&keys);
let expected = 2 ^ 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a ^ &b;
let decrypted = c.decrypt(&keys);
let expected = 2 ^ 1;
assert_eq!(decrypted, expected);
The resulting type after applying the ^ operator.
Performs the ^ operation. Read more

Allows using the ^ operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a ^ b;
let decrypted = c.decrypt(&keys);
let expected = 2 ^ 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a ^ &b;
let decrypted = c.decrypt(&keys);
let expected = 2 ^ 1;
assert_eq!(decrypted, expected);
The resulting type after applying the ^ operator.
Performs the ^ operation. Read more

Allows using the ^= operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a ^= b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected ^= 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a ^= &b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected ^= 1;
assert_eq!(decrypted, expected);
Performs the ^= operation. Read more
Returns a copy of the value. Read more
Performs copy-assignment from source. Read more
Deserialize this value from the given Serde deserializer. Read more
The resulting type after applying the / operator.
Performs the / operation. Read more
The resulting type after applying the / operator.
Performs the / operation. Read more

Allows using the / operator between a &GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a / b;
let decrypted = c.decrypt(&keys);
let expected = 2 / 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a / &b;
let decrypted = c.decrypt(&keys);
let expected = 2 / 1;
assert_eq!(decrypted, expected);
The resulting type after applying the / operator.
Performs the / operation. Read more

Allows using the / operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a / b;
let decrypted = c.decrypt(&keys);
let expected = 2 / 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a / &b;
let decrypted = c.decrypt(&keys);
let expected = 2 / 1;
assert_eq!(decrypted, expected);
The resulting type after applying the / operator.
Performs the / operation. Read more
The resulting type after applying the / operator.
Performs the / operation. Read more
The resulting type after applying the / operator.
Performs the / operation. Read more

Allows using the /= operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a /= b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected /= 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a /= &b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected /= 1;
assert_eq!(decrypted, expected);
Performs the /= operation. Read more
Compute a function over an encrypted message, and returns a new encrypted value containing the result. Read more
Compute a function over the encrypted message.

Decrypt the encrypted value to a u8

Example
use concrete::OutOfRangeError;
use concrete::prelude::*;

let a = FheUint2::try_encrypt(2, &client_key)?;
let a_clear = a.decrypt(&client_key);
assert_eq!(a_clear, 2);

let a = FheUint3::try_encrypt(7, &client_key)?;
let a_clear = a.decrypt(&client_key);
assert_eq!(a_clear, 7);

Try to create a new value.

As Shortints exposed by this crate have between 2 and 7 bits, creating a value from a rust u8 may not be possible.

Example
use concrete::prelude::*;
use concrete::OutOfRangeError;

// The maximum value that can be represented with 3 bits is 7.
let a = FheUint3::try_encrypt(8, &client_key);
assert_eq!(a.is_err(), true);

let a = FheUint3::try_encrypt(7, &client_key);
assert_eq!(a.is_ok(), true);
The resulting type after applying the * operator.
Performs the * operation. Read more
The resulting type after applying the * operator.
Performs the * operation. Read more

Allows using the * operator between a &GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a * b;
let decrypted = c.decrypt(&keys);
let expected = 2 * 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a * &b;
let decrypted = c.decrypt(&keys);
let expected = 2 * 1;
assert_eq!(decrypted, expected);
The resulting type after applying the * operator.
Performs the * operation. Read more

Allows using the * operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a * b;
let decrypted = c.decrypt(&keys);
let expected = 2 * 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a * &b;
let decrypted = c.decrypt(&keys);
let expected = 2 * 1;
assert_eq!(decrypted, expected);
The resulting type after applying the * operator.
Performs the * operation. Read more
The resulting type after applying the * operator.
Performs the * operation. Read more
The resulting type after applying the * operator.
Performs the * operation. Read more

Allows using the *= operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a *= b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected *= 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a *= &b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected *= 1;
assert_eq!(decrypted, expected);
Performs the *= operation. Read more
Performs the *= operation. Read more
The resulting type after applying the - operator.
Performs the unary - operation. Read more
The resulting type after applying the - operator.
Performs the unary - operation. Read more
Method which takes an iterator and generates Self from the elements by multiplying the items. Read more
The resulting type after applying the % operator.
Performs the % operation. Read more
The resulting type after applying the % operator.
Performs the % operation. Read more
The resulting type after applying the % operator.
Performs the % operation. Read more
The resulting type after applying the % operator.
Performs the % operation. Read more
Serialize this value into the given Serde serializer. Read more
The resulting type after applying the << operator.
Performs the << operation. Read more
The resulting type after applying the << operator.
Performs the << operation. Read more
The resulting type after applying the << operator.
Performs the << operation. Read more
The resulting type after applying the << operator.
Performs the << operation. Read more
The resulting type after applying the >> operator.
Performs the >> operation. Read more
The resulting type after applying the >> operator.
Performs the >> operation. Read more
The resulting type after applying the >> operator.
Performs the >> operation. Read more
The resulting type after applying the >> operator.
Performs the >> operation. Read more
The resulting type after applying the - operator.
Performs the - operation. Read more
The resulting type after applying the - operator.
Performs the - operation. Read more

Allows using the - operator between a &GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a - b;
let decrypted = c.decrypt(&keys);
let expected = 2 - 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = &a - &b;
let decrypted = c.decrypt(&keys);
let expected = 2 - 1;
assert_eq!(decrypted, expected);
The resulting type after applying the - operator.
Performs the - operation. Read more

Allows using the - operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a - b;
let decrypted = c.decrypt(&keys);
let expected = 2 - 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
let c = a - &b;
let decrypted = c.decrypt(&keys);
let expected = 2 - 1;
assert_eq!(decrypted, expected);
The resulting type after applying the - operator.
Performs the - operation. Read more
The resulting type after applying the - operator.
Performs the - operation. Read more
The resulting type after applying the - operator.
Performs the - operation. Read more

Allows using the -= operator between a GenericFheUint and a GenericFheUint or a &GenericFheUint

Examples

use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a -= b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected -= 1;
assert_eq!(decrypted, expected);
use concrete::prelude::*;
use concrete::{generate_keys, set_server_key, ConfigBuilder, FheUint2};
 
let config = ConfigBuilder::all_disabled()
    .enable_default_uint2()
    .build();
let (keys, server_key) = generate_keys(config);
 
let mut a = FheUint2::try_encrypt(2, &keys)?;
let b = FheUint2::try_encrypt(1, &keys)?;
 
set_server_key(server_key);
 
a -= &b;
let decrypted = a.decrypt(&keys);
let mut expected = 2;
expected -= 1;
assert_eq!(decrypted, expected);
Performs the -= operation. Read more
Performs the -= operation. Read more
Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The alignment of pointer.
The type for initializers.
Initializes a with the given initializer. Read more
Dereferences the given pointer. Read more
Mutably dereferences the given pointer. Read more
Drops the object pointed to by the given pointer. Read more
Should always be Self
The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.