Struct tfhe :: FheUint Copy item path

impl<Id: FheUintId> FheUint<Id>

pub fn generate_oblivious_pseudo_random( seed: Seed, random_bits_count: u64 ) -> Self

Generates an encrypted num_block blocks unsigned integer taken uniformly in [0, 2^random_bits_count[ using the given seed The encryted value is oblivious to the server It can be useful to make server random generation deterministic

use tfhe::prelude::FheDecrypt;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint8, Seed};

let config = ConfigBuilder::default().build();
let (client_key, server_key) = generate_keys(config);

set_server_key(server_key);

let random_bits_count = 3;

let ct_res = FheUint8::generate_oblivious_pseudo_random(Seed(0), random_bits_count);

let dec_result: u16 = ct_res.decrypt(&client_key);
assert!(dec_result < (1 << random_bits_count));

pub fn current_device(&self) -> Device

Returns the device where the ciphertext is currently on

pub fn move_to_device(&mut self, device: Device)

Moves (in-place) the ciphertext to the desired device.

Does nothing if the ciphertext is already in the desired device

pub fn try_decrypt_trivial<Clear>( &self ) -> Result<Clear, NotTrivialCiphertextError>
where Clear: UnsignedNumeric + RecomposableFrom<u64>,

Tries to decrypt a trivial ciphertext

Trivial ciphertexts are ciphertexts which are not encrypted meaning they can be decrypted by any key, or even without a key.

For debugging it can be useful to use trivial ciphertext to speed up execution, and use Self::try_decrypt_trivial to decrypt temporary values and debug.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

// This is not a trivial ciphertext as we use a client key to encrypt.
let non_trivial = FheUint16::encrypt(1u16, &client_key);
// This is a trivial ciphertext
let trivial = FheUint16::encrypt_trivial(2u16);

// We can trivial decrypt
let result: Result<u16, _> = trivial.try_decrypt_trivial();
assert_eq!(result, Ok(2));

// We cannot trivial decrypt
let result: Result<u16, _> = non_trivial.try_decrypt_trivial();
matches!(result, Err(_));

pub fn is_trivial(&self) -> bool

Returns true if the ciphertext is a trivial encryption

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let non_trivial = FheUint16::encrypt(1u16, &client_key);
assert!(!non_trivial.is_trivial());

let trivial = FheUint16::encrypt_trivial(2u16);
assert!(trivial.is_trivial());

pub fn sum<'a, C>(collection: C) -> Self
where C: AsRef<[&'a Self]>,

Sums multiple ciphertexts together.

This is much more efficient than manually calling the + operator, thus using sum should always be preferred.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(1u16, &client_key);
let b = FheUint16::encrypt(2u16, &client_key);
let c = FheUint16::encrypt(3u16, &client_key);

let result = FheUint16::sum([&a, &b, &c]);
let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, 1u16 + 2 + 3);

// Or
let result = [&a, &b, &c].into_iter().sum::<FheUint16>();
let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, 1u16 + 2 + 3);

pub fn leading_zeros(&self) -> FheUint32

Returns the number of leading zeros in the binary representation of self.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(0b00111111_11111111u16, &client_key);

let result = a.leading_zeros();
let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, 2);

pub fn leading_ones(&self) -> FheUint32

Returns the number of leading ones in the binary representation of self.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(0b11000000_00000000u16, &client_key);

let result = a.leading_ones();
let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, 2);

pub fn trailing_zeros(&self) -> FheUint32

Returns the number of trailing zeros in the binary representation of self.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(0b0000000_0101000u16, &client_key);

let result = a.trailing_zeros();
let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, 3);

pub fn trailing_ones(&self) -> FheUint32

Returns the number of trailing ones in the binary representation of self.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(0b0000000_0110111u16, &client_key);

let result = a.trailing_ones();
let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, 3);

pub fn ilog2(&self) -> FheUint32

Returns the base 2 logarithm of the number, rounded down.

Result has no meaning if self encrypts 0. See Self::checked_ilog2

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(2u16, &client_key);

let result = a.ilog2();
let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, 1);

pub fn checked_ilog2(&self) -> (FheUint32, FheBool)

Returns the base 2 logarithm of the number, rounded down.

Also returns a boolean flag that is true if the result is valid (i.e self was > 0)

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheBool, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(0u16, &client_key);

let (result, is_ok) = a.checked_ilog2();

let is_ok = is_ok.decrypt(&client_key);
assert_eq!(is_ok, false);

let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, 63); // result is meaningless

impl<Id> FheUint<Id>
where Id: FheUintId,

pub fn compress(&self) -> CompressedFheUint<Id>

impl<Id> FheUint<Id>
where Id: FheUintId, WopbsKey: WopbsEvaluationKey<ServerKey, RadixCiphertext>,

The operation is modular, i.e on overflow it wraps around.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = 23u16;
let b = FheUint16::encrypt(3u16, &client_key);

let result = a + &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 23u16 + 3u16);

The operation is modular, i.e on overflow it wraps around.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(23u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = &a + &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 23u16 + 3u16);

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = 23u16;
let b = FheUint16::encrypt(3u16, &client_key);

let result = a & &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 23u16 & 3u16);

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

let result = &a & &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result,  3u16 & 37849u16);

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheUint16::encrypt(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

a &= &b;
let result: u16 = a.decrypt(&client_key);
assert_eq!(result, 3u16 & 37849u16);

impl BitOr<&FheUint<FheUint16Id>> for &u16

fn bitor(self, rhs: &FheUint16) -> Self::Output

Performs a bitwise ‘or’ between a clear and super::FheUint16

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = 23u16;
let b = FheUint16::encrypt(3u16, &client_key);

let result = a | &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 23u16 | 3u16);

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

let result = &a | &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result,  3u16 | 37849u16);

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheUint16::encrypt(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

a |= &b;
let result: u16 = a.decrypt(&client_key);
assert_eq!(result, 3u16 | 37849u16);

impl BitXor<&FheUint<FheUint16Id>> for &u16

fn bitxor(self, rhs: &FheUint16) -> Self::Output

Performs a bitwise ‘xor’ between a clear and super::FheUint16

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = 23u16;
let b = FheUint16::encrypt(3u16, &client_key);

let result = a ^ &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 23u16 ^ 3u16);

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

let result = &a ^ &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result,  3u16 ^ 37849u16);

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl<'de, Id> Deserialize<'de> for FheUint<Id>
where Id: Deserialize<'de> + FheUintId,

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

Deserialize this value from the given Serde deserializer. Read more

impl<Id, B> Div for &FheUint<Id>
where Id: FheUintId, B: Borrow<FheUint<Id>>,

fn div(self, rhs: B) -> Self::Output

Divides two FheUint and returns the quotient

§Note

If you need both the quotient and remainder, then prefer to use FheUint::div_rem, instead of using / and % separately.

When the divisor is 0, the returned quotient will be the max value (i.e. all bits set to 1).

This behaviour should not be relied on.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = &a / &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 37849u16 / 3u16);

type Output = FheUint<Id>

If you need both the quotient and remainder, then prefer to use FheUint::div_rem, instead of using / and % separately.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

a /= &b;
let result: u16 = a.decrypt(&client_key);
assert_eq!(result, 37849u16 / 3u16);

§Notes

When the divisor is 0, the returned quotient will be the max value (i.e. all bits set to 1), the remainder will be the value of the numerator.

This behaviour should not be relied on.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(23u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let (quotient, remainder) = (&a).div_rem(&b);

let quotient: u16 = quotient.decrypt(&client_key);
assert_eq!(quotient, 23u16 / 3u16);
let remainder: u16 = remainder.decrypt(&client_key);
assert_eq!(remainder, 23u16 % 3u16);

Compute a function over an encrypted message, and returns a new encrypted value containing the result.

fn apply<F: Fn(u64) -> u64>(&mut self, func: F)

Compute a function over the encrypted message.

impl<Id, ClearType> FheDecrypt<ClearType> for FheUint<Id>
where Id: FheUintId, ClearType: RecomposableFrom<u64> + UnsignedNumeric,

fn decrypt(&self, key: &ClientKey) -> ClearType

Decrypts a FheUint to an unsigned type.

The unsigned type has to be explicit.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(7288u16, &client_key);

// u16 is explicit
let decrypted: u16 = a.decrypt(&client_key);
assert_eq!(decrypted, 7288u16);

// u32 is explicit
let decrypted: u32 = a.decrypt(&client_key);
assert_eq!(decrypted, 7288u32);

Test for equality between a FheUint and a clear

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(1u16, &client_key);
let b = 2u16;

let result = a.eq(b);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, 1u16 == 2u16);

fn ne(&self, rhs: Clear) -> FheBool

Test for difference between a FheUint and a clear

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(1u16, &client_key);
let b = 2u16;

let result = a.ne(b);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, 1u16 != 2u16);

impl<Id> FheEq for FheUint<Id>
where Id: FheUintId,

fn eq(&self, rhs: Self) -> FheBool

fn ne(&self, rhs: Self) -> FheBool

Test for less than between a FheUint and a clear value

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(1u16, &client_key);
let b = 2u16;

let result = a.lt(b);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, 1u16 < 2u16);

fn le(&self, rhs: Clear) -> FheBool

Test for less than or equal between a FheUint and a clear value

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(1u16, &client_key);
let b = 2u16;

let result = a.le(b);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, 1u16 <= 2u16);

fn gt(&self, rhs: Clear) -> FheBool

Test for greater than between a FheUint and a clear value

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(1u16, &client_key);
let b = 2u16;

let result = a.gt(b);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, 1u16 > 2u16);

fn ge(&self, rhs: Clear) -> FheBool

Test for greater than or equal between a FheUint and a clear value

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(1u16, &client_key);
let b = 2u16;

let result = a.ge(b);

let decrypted = result.decrypt(&client_key);
assert_eq!(decrypted, 1u16 >= 2u16);

Thus no client or public key is needed to create a trivial encryption, this can be useful to initialize some values.

As soon as a trivial encryption is used in an operation that involves non trivial encryption, the result will be non trivial (secure).

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt_trivial(7288u16);

let decrypted: u16 = a.decrypt(&client_key);
assert_eq!(decrypted, 7288u16);

if self is true, the output will have the value of ct_then
if self is false, the output will have the value of ct_else

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = 23u16;
let b = FheUint16::encrypt(3u16, &client_key);

let result = a * &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 23u16 * 3u16);

The operation is modular, i.e on overflow it wraps around.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

let result = &a * &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 3u16.wrapping_mul(37849u16));

impl<Id> Neg for &FheUint<Id>
where Id: FheUintId,

fn neg(self) -> Self::Output

Computes the negation of a FheUint.

Since FheUint are unsigned integers meaning the value they can represent is always positive, negating a FheUint will yield a positive number.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3u16, &client_key);

let result = -&a;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 3u16.wrapping_neg());

type Output = FheUint<Id>

The resulting type after applying the - operator.

impl<Id> Neg for FheUint<Id>
where Id: FheUintId,

fn neg(self) -> Self::Output

Computes the negation of a FheUint.

Since FheUint are unsigned integers meaning the value they can represent is always positive, negating a FheUint will yield a positive number.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3u16, &client_key);

let result = -a;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 3u16.wrapping_neg());

type Output = FheUint<Id>

The resulting type after applying the - operator.

impl<Id> Not for &FheUint<Id>
where Id: FheUintId,

fn not(self) -> Self::Output

Performs a bitwise ‘not’

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3u16, &client_key);

let result = !&a;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, !3u16);

type Output = FheUint<Id>

The resulting type after applying the ! operator.

impl<Id> Not for FheUint<Id>
where Id: FheUintId,

fn not(self) -> Self::Output

Performs a bitwise ‘not’

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3u16, &client_key);

let result = !a;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, !3u16);

type Output = FheUint<Id>

The resulting type after applying the ! operator.

impl<Id> OverflowingAdd<&FheUint<Id>> for &FheUint<Id>
where Id: FheUintId,

fn overflowing_add(self, other: Self) -> (Self::Output, FheBool)

Adds two FheUint and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(u16::MAX, &client_key);
let b = FheUint16::encrypt(1u16, &client_key);

let (result, overflowed) = (&a).overflowing_add(&b);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, u16::MAX.wrapping_add(1u16));
assert_eq!(
    overflowed.decrypt(&client_key),
    u16::MAX.overflowing_add(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

impl<Id> OverflowingAdd<&FheUint<Id>> for FheUint<Id>
where Id: FheUintId,

fn overflowing_add(self, other: &Self) -> (Self::Output, FheBool)

Adds two FheUint and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(u16::MAX, &client_key);
let b = FheUint16::encrypt(1u16, &client_key);

let (result, overflowed) = a.overflowing_add(&b);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, u16::MAX.wrapping_add(1u16));
assert_eq!(
    overflowed.decrypt(&client_key),
    u16::MAX.overflowing_add(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

impl<Id, Clear> OverflowingAdd<Clear> for &FheUint<Id>
where Id: FheUintId, Clear: UnsignedNumeric + DecomposableInto<u8>,

fn overflowing_add(self, other: Clear) -> (Self::Output, FheBool)

Adds a FheUint with a Clear and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(u16::MAX, &client_key);

let (result, overflowed) = (&a).overflowing_add(1u16);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, u16::MAX.wrapping_add(1u16));
assert_eq!(
    overflowed.decrypt(&client_key),
    u16::MAX.overflowing_add(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

impl<Id, Clear> OverflowingAdd<Clear> for FheUint<Id>
where Id: FheUintId, Clear: UnsignedNumeric + DecomposableInto<u8>,

fn overflowing_add(self, other: Clear) -> (Self::Output, FheBool)

Adds a FheUint with a Clear and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(u16::MAX, &client_key);

let (result, overflowed) = a.overflowing_add(1u16);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, u16::MAX.wrapping_add(1u16));
assert_eq!(
    overflowed.decrypt(&client_key),
    u16::MAX.overflowing_add(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

impl<Id> OverflowingMul<&FheUint<Id>> for &FheUint<Id>
where Id: FheUintId,

fn overflowing_mul(self, other: Self) -> (Self::Output, FheBool)

Multiplies two FheUint and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3434u16, &client_key);
let b = FheUint16::encrypt(54u16, &client_key);

let (result, overflowed) = (&a).overflowing_mul(&b);
let (expected_result, expected_overflowed) = 3434u16.overflowing_mul(54u16);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, expected_result);
assert_eq!(overflowed.decrypt(&client_key), expected_overflowed);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

impl<Id> OverflowingMul<&FheUint<Id>> for FheUint<Id>
where Id: FheUintId,

fn overflowing_mul(self, other: &Self) -> (Self::Output, FheBool)

Multiplies two FheUint and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3434u16, &client_key);
let b = FheUint16::encrypt(54u16, &client_key);

let (result, overflowed) = a.overflowing_mul(&b);
let (expected_result, expected_overflowed) = 3434u16.overflowing_mul(54u16);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, expected_result);
assert_eq!(overflowed.decrypt(&client_key), expected_overflowed);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

impl<Id> OverflowingSub<&FheUint<Id>> for &FheUint<Id>
where Id: FheUintId,

fn overflowing_sub(self, other: Self) -> (Self::Output, FheBool)

Subtracts two FheUint and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(0u16, &client_key);
let b = FheUint16::encrypt(1u16, &client_key);

let (result, overflowed) = (&a).overflowing_sub(&b);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 0u16.wrapping_sub(1u16));
assert_eq!(
    overflowed.decrypt(&client_key),
    0u16.overflowing_sub(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

impl<Id> OverflowingSub<&FheUint<Id>> for FheUint<Id>
where Id: FheUintId,

fn overflowing_sub(self, other: &Self) -> (Self::Output, FheBool)

Subtracts two FheUint and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(0u16, &client_key);
let b = FheUint16::encrypt(1u16, &client_key);

let (result, overflowed) = a.overflowing_sub(&b);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 0u16.wrapping_sub(1u16));
assert_eq!(
    overflowed.decrypt(&client_key),
    0u16.overflowing_sub(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

impl<Id, Clear> OverflowingSub<Clear> for &FheUint<Id>
where Id: FheUintId, Clear: UnsignedNumeric + DecomposableInto<u8>,

fn overflowing_sub(self, other: Clear) -> (Self::Output, FheBool)

Subtracts a FheUint with a Clear and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(0u16, &client_key);

let (result, overflowed) = (&a).overflowing_sub(1u16);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 0u16.wrapping_sub(1u16));
assert_eq!(
    overflowed.decrypt(&client_key),
    0u16.overflowing_sub(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

impl<Id, Clear> OverflowingSub<Clear> for FheUint<Id>
where Id: FheUintId, Clear: UnsignedNumeric + DecomposableInto<u8>,

fn overflowing_sub(self, other: Clear) -> (Self::Output, FheBool)

Subtracts a FheUint with a Clear and returns a boolean indicating overflow.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(0u16, &client_key);

let (result, overflowed) = a.overflowing_sub(1u16);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 0u16.wrapping_sub(1u16));
assert_eq!(
    overflowed.decrypt(&client_key),
    0u16.overflowing_sub(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);

This behaviour should not be relied on.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = &a % &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 37849u16 % 3u16);

type Output = FheUint<Id>

If you need both the quotient and remainder, then prefer to use FheUint::div_rem, instead of using / and % separately.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

a %= &b;
let result: u16 = a.decrypt(&client_key);
assert_eq!(result, 37849u16 % 3u16);

impl<Id, Id2> RotateLeft<&FheUint<Id2>> for &FheInt<Id>
where Id: FheIntId, Id2: FheUintId,

fn rotate_left(self, rhs: &FheUint<Id2>) -> Self::Output

Performs a bitwise left rotation of a FheInt by a FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheInt16, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheInt16::encrypt(7849i16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = (&a).rotate_left(&b);
let result: i16 = result.decrypt(&client_key);
assert_eq!(result, 7849i16.rotate_left(3));

type Output = FheInt<Id>

impl<Id, Id2> RotateLeft<&FheUint<Id2>> for &FheUint<Id>
where Id: FheUintId, Id2: FheUintId,

fn rotate_left(self, rhs: &FheUint<Id2>) -> Self::Output

Performs a bitwise left rotation of a FheUint by another FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = (&a).rotate_left(&b);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 37849u16.rotate_left(3));

Performs a left bit rotation and assign operation on FheInt

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheInt16, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheInt16::encrypt(7849i16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

a.rotate_left_assign(&b);
let result: i16 = a.decrypt(&client_key);
assert_eq!(result, 7849i16.rotate_left(3));

impl<Id, Id2> RotateLeftAssign<&FheUint<Id2>> for FheUint<Id>
where Id: FheUintId, Id2: FheUintId,

fn rotate_left_assign(&mut self, rhs: &FheUint<Id2>)

Performs a left bit rotation and assign operation on FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

a.rotate_left_assign(&b);
let result: u16 = a.decrypt(&client_key);
assert_eq!(result, 37849u16.rotate_left(3));

Performs a bitwise right rotation of a FheInt by a FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheInt16, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheInt16::encrypt(7849i16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = (&a).rotate_right(&b);
let result: i16 = result.decrypt(&client_key);
assert_eq!(result, 7849i16.rotate_right(3));

type Output = FheInt<Id>

impl<Id, Id2> RotateRight<&FheUint<Id2>> for &FheUint<Id>
where Id: FheUintId, Id2: FheUintId,

fn rotate_right(self, rhs: &FheUint<Id2>) -> Self::Output

Performs a bitwise right rotation of a FheUint by another FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = (&a).rotate_right(&b);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 37849u16.rotate_right(3));

Performs a right bit rotation and assign operation on FheInt

§Note

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheInt16, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheInt16::encrypt(7849i16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

a.rotate_right_assign(&b);
let result: i16 = a.decrypt(&client_key);
assert_eq!(result, 7849i16.rotate_right(3));

impl<Id, Id2> RotateRightAssign<&FheUint<Id2>> for FheUint<Id>
where Id: FheUintId, Id2: FheUintId,

fn rotate_right_assign(&mut self, rhs: &FheUint<Id2>)

Performs a right bit rotation and assign operation on FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

a.rotate_right_assign(&b);
let result: u16 = a.decrypt(&client_key);
assert_eq!(result, 37849u16.rotate_right(3));

Serialize this value into the given Serde serializer. Read more

impl<Id, Id2> Shl<&FheUint<Id2>> for &FheInt<Id>
where Id: FheIntId, Id2: FheUintId,

fn shl(self, rhs: &FheUint<Id2>) -> Self::Output

Performs a bitwise left shift of a FheInt by a FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheInt16, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheInt16::encrypt(7849i16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = &a << &b;
let result: i16 = result.decrypt(&client_key);
assert_eq!(result, 7849i16 << 3u16);

type Output = FheInt<Id>

The resulting type after applying the << operator.

impl<Id, Id2> Shl<&FheUint<Id2>> for &FheUint<Id>
where Id: FheUintId, Id2: FheUintId,

fn shl(self, rhs: &FheUint<Id2>) -> Self::Output

Performs a bitwise left shift of a FheUint by another FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = &a << &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 37849u16 << 3u16);

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheInt16, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheInt16::encrypt(7849i16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

a <<= &b;
let result: i16 = a.decrypt(&client_key);
assert_eq!(result, 7849i16 << 3u16);

Performs a bitwise right shift of a FheInt by a FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheInt16, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheInt16::encrypt(7849i16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = &a >> &b;
let result: i16 = result.decrypt(&client_key);
assert_eq!(result, 7849i16 >> 3u16);

type Output = FheInt<Id>

The resulting type after applying the >> operator.

impl<Id, Id2> Shr<&FheUint<Id2>> for &FheUint<Id>
where Id: FheUintId, Id2: FheUintId,

fn shr(self, rhs: &FheUint<Id2>) -> Self::Output

Performs a bitwise right shift of a FheUint by another FheUint

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(37849u16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

let result = &a >> &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 37849u16 >> 3u16);

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheInt16, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let mut a = FheInt16::encrypt(7849i16, &client_key);
let b = FheUint16::encrypt(3u16, &client_key);

a >>= &b;
let result: i16 = a.decrypt(&client_key);
assert_eq!(result, 7849i16 >> 3u16);

Subtract a super::FheUint16 to a clear

The operation is modular, i.e on overflow it wraps around.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = 23u16;
let b = FheUint16::encrypt(3u16, &client_key);

let result = a - &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 23u16 - 3u16);

The operation is modular, i.e on overflow it wraps around.

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

let result = &a - &b;
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, 3u16.wrapping_sub(37849u16));

impl<Clear, Key, T> FheEncrypt<Clear, Key> for T
where T: FheTryEncrypt<Clear, Key>,

fn encrypt(value: Clear, key: &Key) -> T

Available on crate feature integer only.

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

The operation is modular, i.e on overflow the result wraps around.
On overflow the FheBool is true, otherwise false

§Example

use tfhe::prelude::*;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint16};

let (client_key, server_key) = generate_keys(ConfigBuilder::default());
set_server_key(server_key);

let a = FheUint16::encrypt(u16::MAX, &client_key);

// Due to conflicts with u16::overflowing_add method
// we have to use this syntax to help the compiler
let (result, overflowed) = OverflowingAdd::overflowing_add(1u16, &a);
let result: u16 = result.decrypt(&client_key);
assert_eq!(result, u16::MAX.wrapping_add(1u16));
assert_eq!(
    overflowed.decrypt(&client_key),
    u16::MAX.overflowing_add(1u16).1
);
assert_eq!(overflowed.decrypt(&client_key), true);

type Output = FheUint<Id>

Available on crate feature integer only.

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>