Struct FheUint

Source

pub struct FheUint<Id: FheUintId> { /* private fields */ }

Available on crate feature integer only.

Expand description

A Generic FHE unsigned integer

This struct is generic over some Id, as its the Id that controls how many bit they represent.

You will need to use one of this type specialization (e.g., FheUint8, FheUint12, FheUint16).

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

Implementations§

Source §

impl<Id: FheUintId> FheUint<Id>

Source

pub fn generate_oblivious_pseudo_random(seed: Seed) -> Self

Generates an encrypted unsigned integer taken uniformly in its full range using the given seed. The encrypted 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 ct_res = FheUint8::generate_oblivious_pseudo_random(Seed(0));

let dec_result: u16 = ct_res.decrypt(&client_key);

Source

pub fn get_generate_oblivious_pseudo_random_size_on_gpu() -> u64

Available on crate feature gpu only.

Returns the amount of memory required to execute generate_oblivious_pseudo_random

use tfhe::core_crypto::gpu::check_valid_cuda_malloc_assert_oom;
use tfhe::prelude::FheDecrypt;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint8, GpuIndex, 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 size = FheUint8::get_generate_oblivious_pseudo_random_size_on_gpu();

check_valid_cuda_malloc_assert_oom(size, GpuIndex::new(0));

Source

pub fn generate_oblivious_pseudo_random_bounded( 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_bounded(Seed(0), random_bits_count);

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

Source

pub fn get_generate_oblivious_pseudo_random_bounded_size_on_gpu() -> u64

Available on crate feature gpu only.

Returns the amount of memory required to execute generate_oblivious_pseudo_random_bounded

use tfhe::core_crypto::gpu::check_valid_cuda_malloc_assert_oom;
use tfhe::prelude::FheDecrypt;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint8, GpuIndex, 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 size = FheUint8::get_generate_oblivious_pseudo_random_bounded_size_on_gpu();

check_valid_cuda_malloc_assert_oom(size, GpuIndex::new(0));

Source §

Available on crate feature gpu only.

Returns the indexes of the GPUs where the ciphertext lives

If the ciphertext is on another deive (e.g CPU) then the returned slice is empty

Source

pub fn is_even(&self) -> FheBool

Returns a FheBool that encrypts true if the value is even

§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(32u16, &client_key);

let result = a.is_even();
let decrypted = result.decrypt(&client_key);
assert!(decrypted);

Source

pub fn is_odd(&self) -> FheBool

Returns a FheBool that encrypts true if the value is odd

§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(4393u16, &client_key);

let result = a.is_odd();
let decrypted = result.decrypt(&client_key);
assert!(decrypted);

Source

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();
assert!(result.is_err());

Source

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());

Source

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, 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);

Source

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, 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);

Source

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, 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);

Source

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, 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);

Source

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, 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);

Source

pub fn count_ones(&self) -> FheUint32

Returns the number of 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 clear_a = 0b0000000_0110111u16;
let a = FheUint16::encrypt(clear_a, &client_key);

let result = a.count_ones();
let decrypted: u32 = result.decrypt(&client_key);
assert_eq!(decrypted, clear_a.count_ones());

Source

pub fn count_zeros(&self) -> FheUint32

Returns the number of 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 clear_a = 0b0000000_0110111u16;
let a = FheUint16::encrypt(clear_a, &client_key);

let result = a.count_zeros();
let decrypted: u32 = result.decrypt(&client_key);
assert_eq!(decrypted, clear_a.count_zeros());

Source

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, 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);

Source

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, 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!(!is_ok);

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

Source

pub fn match_value<Clear, OutId>( &self, matches: &MatchValues<Clear>, ) -> Result<(FheUint<OutId>, FheBool)>
where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>, OutId: FheUintId,

match an input value to an output value

Input values are not required to span all possible values that self could hold. And the output type can be different.

Returns a FheBool that encrypts true if the input self matched one of the possible inputs

§Example

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

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

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

let match_values = MatchValues::new(vec![
    (0u16, 3u16),
    (1u16, 3u16),
    (2u16, 3u16),
    (17u16, 25u16),
])
.unwrap();
let (result, matched): (FheUint8, _) = a.match_value(&match_values)
    .unwrap(); // All possible output values fit in a u8

let matched = matched.decrypt(&client_key);
assert!(matched);

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

Source

pub fn match_value_or<Clear, OutId>( &self, matches: &MatchValues<Clear>, or_value: Clear, ) -> Result<FheUint<OutId>>
where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>, OutId: FheUintId,

match an input value to an output value

Input values are not required to span all possible values that self could hold. And the output type can be different.

If none of the input matched the self then, self will encrypt the value given to or_value

§Example

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

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

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

let match_values = MatchValues::new(vec![
    (0u16, 3u16), // map 0 to 3
    (1u16, 234u16),
    (2u16, 123u16),
])
.unwrap();
let result: FheUint8 = a.match_value_or(&match_values, 25u16)
    .unwrap(); // All possible output values fit on a u8

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

Source

pub fn reverse_bits(&self) -> Self

Reverse the bit of the unsigned integer

§Example

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

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

let msg = 0b10110100_u8;

let a = FheUint8::encrypt(msg, &client_key);

let result: FheUint8 = a.reverse_bits();

let decrypted: u8 = result.decrypt(&client_key);
assert_eq!(decrypted, msg.reverse_bits());

Source

pub fn if_then_else<Clear>( condition: &FheBool, true_value: Clear, false_value: Clear, ) -> Self
where Clear: UnsignedNumeric + DecomposableInto<u64>,

Creates a FheUint that encrypts either of two values depending on an encrypted condition

§Example

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

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

let cond = FheBool::encrypt(true, &client_key);

let result = FheUint32::if_then_else(&cond, u32::MAX, u32::MIN);
let decrypted: u32 = result.decrypt(&client_key);
assert_eq!(decrypted, u32::MAX);

let result = FheUint32::if_then_else(&!cond, u32::MAX, u32::MIN);
let decrypted: u32 = result.decrypt(&client_key);
assert_eq!(decrypted, u32::MIN);

Source

pub fn select<Clear>( condition: &FheBool, true_value: Clear, false_value: Clear, ) -> Self
where Clear: UnsignedNumeric + DecomposableInto<u64>,

Same as Self::if_then_else but with a different name

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);

Source §

impl<Id, I> AddSizeOnGpu for FheUint<Id>
where Id: FheUintId, I: Borrow<Self>,

Available on crate feature gpu only.

Source §

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);

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);

Extract a slice of bits from a FheUint.

This function is more efficient if the range starts on a block boundary.

§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 msg: u16 = 225;
let a = FheUint16::encrypt(msg, &client_key);
let start_bit = 3;
let end_bit = 6;

let result = (&a).bitslice(start_bit..end_bit).unwrap();

let decrypted_slice: u16 = result.decrypt(&client_key);
assert_eq!((msg % (1 << end_bit)) >> start_bit, decrypted_slice);

Source §

type Output = FheUint<Id>

Source §

impl<Id, Clear> BitSlice<Clear> for FheUint<Id>
where Id: FheUintId, Clear: CastFrom<usize> + CastInto<usize> + Copy,

Source §

fn bitslice<R>(self, range: R) -> Result<Self::Output, InvalidRangeError>
where R: RangeBounds<Clear>,

Extract a slice of bits from a FheUint.

This function is more efficient if the range starts on a block boundary.

§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 msg: u16 = 225;
let a = FheUint16::encrypt(msg, &client_key);
let start_bit = 3;
let end_bit = 6;

let result = a.bitslice(start_bit..end_bit).unwrap();

let decrypted_slice: u16 = result.decrypt(&client_key);
assert_eq!((msg % (1 << end_bit)) >> start_bit, decrypted_slice);

Source §

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);

Cast a boolean ciphertext to an unsigned ciphertext

§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 = FheBool::encrypt(true, &client_key);
let b = FheUint16::cast_from(a);

let decrypted: u16 = b.decrypt(&client_key);
assert_eq!(decrypted, u16::from(true));

Source §

impl<FromId, IntoId> CastFrom<FheInt<FromId>> for FheUint<IntoId>
where FromId: FheIntId, IntoId: FheUintId,

Source §

fn cast_from(input: FheInt<FromId>) -> Self

Cast a FheInt to an FheUint

§Example

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

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

let a = FheInt32::encrypt(i32::MIN, &client_key);
let b = FheUint16::cast_from(a);

let decrypted: u16 = b.decrypt(&client_key);
assert_eq!(decrypted, i32::MIN as u16);

Source §

impl<FromId, IntoId> CastFrom<FheUint<FromId>> for FheInt<IntoId>
where FromId: FheUintId, IntoId: FheIntId,

Source §

fn cast_from(input: FheUint<FromId>) -> Self

Cast a FheUint to a FheInt

§Example

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

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

let a = FheUint32::encrypt(u32::MAX, &client_key);
let b = FheInt16::cast_from(a);

let decrypted: i16 = b.decrypt(&client_key);
assert_eq!(decrypted, u32::MAX as i16);

Source §

impl<FromId, IntoId> CastFrom<FheUint<FromId>> for FheUint<IntoId>
where FromId: FheUintId, IntoId: FheUintId,

Source §

fn cast_from(input: FheUint<FromId>) -> Self

Cast FheUint to another FheUint

§Example

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

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

let a = FheUint32::encrypt(u32::MAX, &client_key);
let b = FheUint16::cast_from(a);

let decrypted: u16 = b.decrypt(&client_key);
assert_eq!(decrypted, u32::MAX as u16);

Source §

impl<Id: Clone + FheUintId> Clone for FheUint<Id>

Source §

fn clone(&self) -> FheUint<Id>

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

Source §

impl<Id: FheUintId> CudaCompressible for FheUint<Id>

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);

Source §

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);

fn get_div_rem_size_on_gpu(&self, rhs: &Self) -> u64

Source §

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

Available on crate feature gpu only.

§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);

Source §

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);

Source §

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);

Source §

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 = FheUint16::encrypt(2u16, &client_key);

let result = a.max(&b);

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

Source §

type Output = FheUint<Id>

Source §

Source §

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

Returns the min between two 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(1u16, &client_key);
let b = FheUint16::encrypt(2u16, &client_key);

let result = a.min(&b);

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

Source §

type Output = FheUint<Id>

Source §

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);

Source §

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);

Source §

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);

Source §

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);

Available on crate feature gpu only.

§Example

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

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

let a = [true, false, true]
    .into_iter()
    .map(|b| FheBool::encrypt(b, &client_key))
    .collect::<Vec<_>>();

let b = [2u8, 3u8, 4u8];

let result = FheUint8::dot_product(&a, &b);
let decrypted: u8 = result.decrypt(&client_key);
assert_eq!(decrypted, 6u8);

Source §

impl<Id, T> FheTrivialEncrypt<T> for FheUint<Id>
where T: DecomposableInto<u64> + UnsignedNumeric, Id: FheUintId,

Source §

fn encrypt_trivial(value: T) -> Self

Creates a trivially encrypted FheUint

A trivial encryption is not an encryption, the value can be retrieved by anyone as if it were a clear value.

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);

Conditional selection.

The output value returned depends on the value of self.

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

Source §

fn select( &self, ct_when_true: &Ciphertext, ct_when_false: &Ciphertext, ) -> Ciphertext

Source §

fn cmux(&self, ct_then: &Ciphertext, ct_else: &Ciphertext) -> Ciphertext

Source §

impl<Id> IfThenElseSizeOnGpu<FheUint<Id>> for FheBool
where Id: FheUintId,

Available on crate feature gpu only.

§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));

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 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.wrapping_mul(37849u16));

Source §

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

Available on crate feature gpu only.

Source §

fn get_mul_size_on_gpu(&self, rhs: &Self) -> u64

Source §

impl<Id: FheUintId> Named for FheUint<Id>

Source §

const NAME: &'static str = "high_level_api::FheUint"

Default name for the type

Source §

const BACKWARD_COMPATIBILITY_ALIASES: &'static [&'static str] = _

Aliases that should also be accepted for backward compatibility when checking the name of values of this type

Source §

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

Source §

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());

Source §

type Output = FheUint<Id>

The resulting type after applying the - operator.

Source §

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

Source §

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());

Source §

type Output = FheUint<Id>

The resulting type after applying the - operator.

Source §

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

Available on crate feature gpu only.

Source §

fn get_neg_size_on_gpu(&self) -> u64

Source §

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

Source §

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);

Source §

type Output = FheUint<Id>

The resulting type after applying the ! operator.

Source §

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

Source §

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);

Source §

type Output = FheUint<Id>

The resulting type after applying the ! operator.

Source §

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

Source §

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!(overflowed.decrypt(&client_key));

Source §

type Output = FheUint<Id>

Source §

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

Source §

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!(overflowed.decrypt(&client_key));

Source §

type Output = FheUint<Id>

Source §

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

Source §

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!(overflowed.decrypt(&client_key));

Source §

type Output = FheUint<Id>

Source §

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

Source §

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!(overflowed.decrypt(&client_key));

Source §

type Output = FheUint<Id>

Source §

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

Source §

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!(overflowed.decrypt(&client_key));

Source §

type Output = FheUint<Id>

Source §

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

Source §

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!(overflowed.decrypt(&client_key));

§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!(overflowed.decrypt(&client_key));

Source §

type Output = FheUint<Id>

Source §

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

Source §

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!(overflowed.decrypt(&client_key));

Source §

type Output = FheUint<Id>

Source §

impl<Id, Clear> OverflowingSub<Clear> for &FheUint<Id>
where Id: FheUintId, Clear: UnsignedNumeric + DecomposableInto<u8> + Not<Output = Clear> + CastInto<u64>,

Source §

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!(overflowed.decrypt(&client_key));

Source §

type Output = FheUint<Id>

Source §

impl<Id, Clear> OverflowingSub<Clear> for FheUint<Id>
where Id: FheUintId, Clear: UnsignedNumeric + DecomposableInto<u8> + Not<Output = Clear> + CastInto<u64>,

Source §

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!(overflowed.decrypt(&client_key));

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);

Source §

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);

Source §

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

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));

Source §

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

Source §

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));

Source §

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

Performs a right 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_right_assign(&b);
let result: i16 = a.decrypt(&client_key);
assert_eq!(result, 7849i16.rotate_right(3));

Source §

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

Source §

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));

fn get_rotate_right_size_on_gpu(&self, rhs: &Self) -> u64

Source §

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

Available on crate feature gpu only.

Source §

fn get_rotate_right_size_on_gpu(&self, rhs: &FheUint<Id2>) -> u64

Source §

impl<Id, Scalar> ScalarIfThenElse<&FheUint<Id>, Scalar> for FheBool
where Id: FheUintId, Scalar: DecomposableInto<u64> + UnsignedNumeric,

Source §

fn scalar_if_then_else( &self, then_value: &FheUint<Id>, else_value: Scalar, ) -> Self::Output

§Example

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

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

let a = FheUint32::encrypt(u32::MAX, &client_key);
let b = 1u32;
let cond = FheBool::encrypt(true, &client_key);

let result = cond.scalar_if_then_else(&a, b);
let decrypted: u32 = result.decrypt(&client_key);
assert_eq!(decrypted, u32::MAX);

let result = (!cond).scalar_if_then_else(&a, b);
let decrypted: u32 = result.decrypt(&client_key);
assert_eq!(decrypted, 1);

Source §

type Output = FheUint<Id>

Source §

Source §

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

Source §

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);

Source §

type Output = FheInt<Id>

The resulting type after applying the << operator.

Source §

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

Source §

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);

Performs the <<= 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 <<= &b;
let result: u16 = a.decrypt(&client_key);
assert_eq!(result, 37849u16 << 3u16);

Source §

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

Source §

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

Performs the <<= operation. Read more

Source §

impl<Id, Id2> ShlAssign<FheUint<Id2>> for FheUint<Id>
where Id: FheUintId, Id2: FheUintId,

Source §

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

Performs the <<= operation. Read more

Source §

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

Available on crate feature gpu only.

Source §

fn get_left_shift_size_on_gpu(&self, rhs: &Self) -> u64

Source §

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

Available on crate feature gpu only.

Source §

fn get_left_shift_size_on_gpu(&self, rhs: &FheUint<Id2>) -> u64

Source §

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

Source §

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

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);

Source §

type Output = FheInt<Id>

The resulting type after applying the >> operator.

Source §

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

Source §

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);

Performs the >>= 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 >>= &b;
let result: u16 = a.decrypt(&client_key);
assert_eq!(result, 37849u16 >> 3u16);

Source §

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

Source §

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

Performs the >>= operation. Read more

Source §

impl<Id, Id2> ShrAssign<FheUint<Id2>> for FheUint<Id>
where Id: FheUintId, Id2: FheUintId,

Source §

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

Performs the >>= operation. Read more

Subtracts two FheUint

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));

Source §

impl<Id, I> SubSizeOnGpu for FheUint<Id>
where Id: FheUintId, I: Borrow<Self>,

Available on crate feature gpu only.

Source §

fn get_sub_size_on_gpu(&self, rhs: I) -> u64

Source §

impl<'a, Id> Sum<&'a FheUint<Id>> for FheUint<Id>
where Id: FheUintId,

Source §

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> 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, FheUint16};

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

let clears = [1, 2, 3, 4, 5];
let encrypted = clears
    .iter()
    .copied()
    .map(|x| FheUint16::encrypt(x, &client_key))
    .collect::<Vec<_>>();

// Iter and sum on references
let result = encrypted.iter().sum::<FheUint16>();

let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, clears.into_iter().sum::<u16>());

Source §

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

Source §

fn sum<I: Iterator<Item = Self>>(iter: I) -> 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, FheUint16};

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

let clears = [1, 2, 3, 4, 5];
let encrypted = clears
    .iter()
    .copied()
    .map(|x| FheUint16::encrypt(x, &client_key))
    .collect::<Vec<_>>();

// Iter and sum consuming (moving out) from the original Vec
let result = encrypted.into_iter().sum::<FheUint16>();

let decrypted: u16 = result.decrypt(&client_key);
assert_eq!(decrypted, clears.into_iter().sum::<u16>());

fn try_from(other: RadixCiphertext) -> Result<Self, GenericIntegerBlockError>

Performs the conversion.

Source §

impl<Id, T> TryFrom<Vec<T>> for FheUint<Id>
where Id: FheUintId, RadixCiphertext: From<Vec<T>>,

Source §

type Error = GenericIntegerBlockError

The type returned in the event of a conversion error.

Source §

fn try_from(blocks: Vec<T>) -> Result<Self, GenericIntegerBlockError>

Performs the conversion.

Source §

impl<Id: FheUintId> Unversionize for FheUint<Id>
where FheUintVersions<Id>: VersionsDispatch<Self>,

Source §

fn unversionize( versioned: Self::VersionedOwned, ) -> Result<Self, UnversionizeError>

Creates an object from a versioned enum, and eventually upgrades from previous variants.

The equivalent versioned type. It should have a variant for each version. It may own the underlying data or only hold a read-only reference to it.

Source §

fn versionize(&self) -> Self::Versioned<'_>

Wraps the object into a versioned enum with a variant for each version. This will use references on the underlying types if possible.

Source §

impl<Id: FheUintId> VersionizeOwned for FheUint<Id>
where FheUintVersions<Id>: VersionsDispatch<Self>,

Source §

type VersionedOwned = <FheUintVersions<Id> as VersionsDispatch<FheUint<Id>>>::Owned

Source §

fn versionize_owned(self) -> Self::VersionedOwned

Wraps the object into a versioned enum with a variant for each version. This will clone the underlying types.

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T> Instrument for T

Source §

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

Source §

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

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

Source §

fn overflowing_add( self, other: &FheUint<Id>, ) -> (<Clear as OverflowingAdd<&FheUint<Id>>>::Output, FheBool)

Available on crate feature integer only.

Adds a Clear with a 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);

// 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!(overflowed.decrypt(&client_key));

Source §

type Output = FheUint<Id>

Available on crate feature integer only.

Source §

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

Source §

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

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

Source §

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

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

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

Source §

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Source §

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Source §

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

Source §

impl<T, Rhs> NumAssignOps<Rhs> for T
where T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,

Source §

impl<T, Rhs, Output> NumOps<Rhs, Output> for T
where T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,

Source §

Struct FheUintCopy item path

Implementations§

impl<Id: FheUintId> FheUint<Id>

pub fn generate_oblivious_pseudo_random(seed: Seed) -> Self

pub fn get_generate_oblivious_pseudo_random_size_on_gpu() -> u64

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

pub fn get_generate_oblivious_pseudo_random_bounded_size_on_gpu() -> u64

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

pub fn into_raw_parts(self) -> (RadixCiphertext, Id, Tag)

pub fn from_raw_parts(ciphertext: RadixCiphertext, id: Id, tag: Tag) -> Self

pub fn num_bits() -> usize

pub fn current_device(&self) -> Device

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

pub fn move_to_current_device(&mut self)

pub fn gpu_indexes(&self) -> &[GpuIndex]

pub fn is_even(&self) -> FheBool

§Example

pub fn is_odd(&self) -> FheBool

§Example

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

§Example

pub fn is_trivial(&self) -> bool

§Example

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

§Example

pub fn leading_zeros(&self) -> FheUint32

§Example

pub fn leading_ones(&self) -> FheUint32

§Example

pub fn trailing_zeros(&self) -> FheUint32

§Example

pub fn trailing_ones(&self) -> FheUint32

§Example

pub fn count_ones(&self) -> FheUint32

§Example

pub fn count_zeros(&self) -> FheUint32

§Example

pub fn ilog2(&self) -> FheUint32

§Example

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

§Example

pub fn match_value<Clear, OutId>( &self, matches: &MatchValues<Clear>, ) -> Result<(FheUint<OutId>, FheBool)>where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>, OutId: FheUintId,

§Example

pub fn match_value_or<Clear, OutId>( &self, matches: &MatchValues<Clear>, or_value: Clear, ) -> Result<FheUint<OutId>>where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>, OutId: FheUintId,

§Example

pub fn reverse_bits(&self) -> Self

§Example

pub fn if_then_else<Clear>( condition: &FheBool, true_value: Clear, false_value: Clear, ) -> Selfwhere Clear: UnsignedNumeric + DecomposableInto<u64>,

§Example

pub fn select<Clear>( condition: &FheBool, true_value: Clear, false_value: Clear, ) -> Selfwhere Clear: UnsignedNumeric + DecomposableInto<u64>,

pub fn cmux<Clear>( condition: &FheBool, true_value: Clear, false_value: Clear, ) -> Selfwhere Clear: UnsignedNumeric + DecomposableInto<u64>,

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

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

Trait Implementations§

impl Add<&FheUint<FheUint1024Id>> for &U1024

type Output = FheUint<FheUint1024Id>

fn add(self, rhs: &FheUint1024) -> Self::Output

impl Add<&FheUint<FheUint1024Id>> for U1024

type Output = FheUint<FheUint1024Id>

fn add(self, rhs: &FheUint1024) -> Self::Output

impl Add<&FheUint<FheUint10Id>> for &u16

type Output = FheUint<FheUint10Id>

fn add(self, rhs: &FheUint10) -> Self::Output

impl Add<&FheUint<FheUint10Id>> for u16

type Output = FheUint<FheUint10Id>

fn add(self, rhs: &FheUint10) -> Self::Output

impl Add<&FheUint<FheUint128Id>> for &u128

type Output = FheUint<FheUint128Id>

fn add(self, rhs: &FheUint128) -> Self::Output

impl Add<&FheUint<FheUint128Id>> for u128

type Output = FheUint<FheUint128Id>

fn add(self, rhs: &FheUint128) -> Self::Output

impl Add<&FheUint<FheUint12Id>> for &u16

type Output = FheUint<FheUint12Id>

fn add(self, rhs: &FheUint12) -> Self::Output

impl Add<&FheUint<FheUint12Id>> for u16

type Output = FheUint<FheUint12Id>

fn add(self, rhs: &FheUint12) -> Self::Output

impl Add<&FheUint<FheUint14Id>> for &u16

type Output = FheUint<FheUint14Id>

Struct FheUint

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

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

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

pub fn match_value<Clear, OutId>( &self, matches: &MatchValues<Clear>, ) -> Result<(FheUint<OutId>, FheBool)>
where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>, OutId: FheUintId,

pub fn match_value_or<Clear, OutId>( &self, matches: &MatchValues<Clear>, or_value: Clear, ) -> Result<FheUint<OutId>>
where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>, OutId: FheUintId,

pub fn if_then_else<Clear>( condition: &FheBool, true_value: Clear, false_value: Clear, ) -> Self
where Clear: UnsignedNumeric + DecomposableInto<u64>,

pub fn select<Clear>( condition: &FheBool, true_value: Clear, false_value: Clear, ) -> Self
where Clear: UnsignedNumeric + DecomposableInto<u64>,

pub fn cmux<Clear>( condition: &FheBool, true_value: Clear, false_value: Clear, ) -> Self
where Clear: UnsignedNumeric + DecomposableInto<u64>,

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