Struct FheUint

Source

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

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

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

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

WARNING: If the requested random_bits_count is 0, then the returned ciphertext is a trivial encryption of 0.

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;

// DANGER: Using a deterministic seed is insecure and only done here to show API usage.
// The proper way of generating a seed depends on your application.
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 generate_oblivious_pseudo_random_bounded_and_re_randomize<'a, RRD: Into<ReRandomizationMode<'a>>>( seed: impl OprfSeed, random_bits_count: u64, re_randomization_mode: RRD, prf_re_randomization_context: &PrfReRandomizationContext, ) -> Result<Self>

Re-randomizing variant of Self::generate_oblivious_pseudo_random_bounded.

WARNING: If the requested random_bits_count is 0, then the returned ciphertext is a trivial encryption of 0.

Source

pub fn generate_oblivious_pseudo_random_custom_range( seed: impl OprfSeed, range: &RangeForRandom, max_distance: Option<f64>, ) -> Self

Generates an encrypted unsigned integer taken almost uniformly in the given range using the given seed. Currently the range can only be in the form [0, excluded_upper_bound[ with any excluded_upper_bound in [1, 2^64[.

The encrypted value is oblivious to the server. It can be useful to make server random generation deterministic.

This function guarantees the the norm-1 distance (defined as ∆(P,Q) := 1/2 Sum[ω∈Ω] |P(ω) − Q(ω)|) between the actual distribution and the target uniform distribution will be below the max_distance argument (which must be in ]0, 1[). The higher the distance, the more dissimilar the actual distribution is from the target uniform distribution.

The default value for max_distance is 2^-128 if None is provided.

Higher values allow better performance but must be considered carefully in the context of their target application as it may have serious unintended consequences.

If the range is a power of 2, the distribution is uniform (for any max_distance) and the cost is smaller.

use std::num::NonZeroU64;
use tfhe::prelude::FheDecrypt;
use tfhe::{generate_keys, set_server_key, ConfigBuilder, FheUint8, RangeForRandom, Seed};

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

set_server_key(server_key);

let excluded_upper_bound = NonZeroU64::new(3).unwrap();

let range = RangeForRandom::new_from_excluded_upper_bound(excluded_upper_bound);

// DANGER: Using a deterministic seed is insecure and only done here to show API usage.
// The proper way of generating a seed depends on your application.
let ct_res = FheUint8::generate_oblivious_pseudo_random_custom_range(Seed(0), &range, None);

let dec_result: u16 = ct_res.decrypt(&client_key);
assert!(dec_result < excluded_upper_bound.get() as u16);

Source

pub fn get_generate_oblivious_pseudo_random_bounded_size_on_gpu() -> u64

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::{generate_keys, set_server_key, ConfigBuilder, FheUint8, GpuIndex};

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

pub fn generate_oblivious_pseudo_random_custom_range_and_re_randomize<'a, RRD: Into<ReRandomizationMode<'a>>>( seed: impl OprfSeed, range: &RangeForRandom, max_distance: Option<f64>, re_randomization_mode: RRD, prf_re_randomization_context: &PrfReRandomizationContext, ) -> Result<Self>

Re-randomizing variant of Self::generate_oblivious_pseudo_random_custom_range.

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

Source

pub fn move_to_current_device(&mut self)

Moves (in-place) the ciphertext to the device of the current thread-local server key

Does nothing if the ciphertext is already in the desired device or if no server key is set

Source

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

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 contains(cts: &[Self], value: &Self) -> FheBool

Returns an encrypted true if value is found in cts.

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

let result = FheUint16::contains(&[a, b, c], &value);
let decrypted = result.decrypt(&client_key);
assert!(decrypted);

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, 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, 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 get_match_value_size_on_gpu<Clear>( &self, matches: &MatchValues<Clear>, ) -> Result<u64>
where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>,

Returns the estimated memory usage (in bytes) required on the GPU to perform the match_value operation.

This is useful to check if the operation fits in the GPU memory before attempting execution.

§Example

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

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

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

let match_values = MatchValues::new(vec![(0u16, 3u16), (17u16, 25u16)]).unwrap();

#[cfg(feature = "gpu")]
{
    let size_bytes = a.get_match_value_size_on_gpu(&match_values).unwrap();
    println!("Memory required on GPU: {} bytes", size_bytes);
    assert!(size_bytes > 0);
}

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 get_match_value_or_size_on_gpu<Clear>( &self, matches: &MatchValues<Clear>, or_value: Clear, ) -> Result<u64>
where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>,

Returns the estimated memory usage (in bytes) required on the GPU to perform the match_value_or operation.

This is useful to check if the operation fits in the GPU memory before attempting execution.

§Example

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

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

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

let match_values = MatchValues::new(vec![(0u16, 3u16), (17u16, 25u16)]).unwrap();

#[cfg(feature = "gpu")]
{
    let size_bytes = a
        .get_match_value_or_size_on_gpu(&match_values, 55u16)
        .unwrap();
    println!("Memory required on GPU: {} bytes", size_bytes);
    assert!(size_bytes > 0);
}

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

Source

pub fn cmux<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

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

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

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

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 §

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

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 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more

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

Source §

type Output = FheUint<Id>

The resulting type after applying the / operator.

Source §

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

Source §

fn div_assign(&mut self, rhs: I)

Performs the /= operation on FheUint

§Note

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

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.eq(&b);

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

Source §

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

Test for difference 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.ne(&b);

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

Source §

impl<Id, Clear> FheEq<Clear> for FheUint<Id>
where Clear: DecomposableInto<u64>, Id: FheUintId,

Source §

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

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

Returns the max 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.max(&b);

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

Source §

type Output = FheUint<Id>

Source §

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

Source §

impl<Id> FheOrdSizeOnGpu<&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, 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);

Source §

fn flip( &self, lhs: &FheUint<Id>, rhs: &FheUint<Id>, ) -> (Self::Output, Self::Output)

Flips the two inputs based on the value of self.

flip(true, a, b) returns (b, a)
flip(false, a, b) returns (a, b)

§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 = u32::MIN;
let b = FheUint32::encrypt(u32::MAX, &client_key);
let cond = FheBool::encrypt(true, &client_key);

let (ra, rb) = cond.flip(a, &b);
let da: u32 = ra.decrypt(&client_key);
let db: u32 = rb.decrypt(&client_key);
assert_eq!((da, db), (u32::MAX, u32::MIN));

fn get_re_randomization_metadata(&self) -> ReRandomizationMetadata

Source §

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

Source §

fn set_re_randomization_metadata(&mut self, meta: ReRandomizationMetadata)

Source §

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

Source §

fn if_then_else( &self, ct_then: &FheUint<Id>, ct_else: &FheUint<Id>, ) -> FheUint<Id>

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.

if self is true, the output will have the value of ct_then
if self is false, the output will be an encryption of 0

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

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 remainder will have 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(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>

The resulting type after applying the % operator.

Source §

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

Source §

fn rem_assign(&mut self, rhs: I)

Performs the %= operation on FheUint

§Note

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 §

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

Available on crate feature gpu only.

Source §

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

Source §

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

Available on crate feature gpu only.

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

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

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

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

Source §

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

Available on crate feature gpu only.

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

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

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: &FheUint<Id2>) -> u64

Source §

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

Available on crate feature gpu only.

Source §

fn get_rotate_right_size_on_gpu(&self, rhs: &Self) -> 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 §

type Output = FheInt<Id>

The resulting type after applying the << operator.

Source §

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

Performs the << operation. Read more

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>

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

If the shift amount is greater than or equal to the number of bits of the type, the result is 0.

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

Source §

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

Source §

Performs the <<= operation. Read more

Source §

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

Available on crate feature gpu only.

Source §

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

Performs the >> operation. Read more

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

If the shift amount is greater than or equal to the number of bits of the type, the result is 0 for non-negative inputs, and -1 for negative inputs (sign-extension).

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

Source §

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

Source §

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

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

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

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

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.

Source §

type Owned = FheUintVersionsDispatchOwned<Id>

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

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)

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>

Source §

Drops the object pointed to by the given pointer. Read more

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

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

Struct FheUint Copy item path

Implementations§

impl<Id: FheUintId> FheUint<Id>

pub fn generate_oblivious_pseudo_random(seed: impl OprfSeed) -> Self

pub fn get_generate_oblivious_pseudo_random_size_on_gpu() -> u64

pub fn generate_oblivious_pseudo_random_and_re_randomize<'a, RRD: Into<ReRandomizationMode<'a>>>( seed: impl OprfSeed, re_randomization_mode: RRD, prf_re_randomization_context: &PrfReRandomizationContext, ) -> Result<Self>

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

pub fn generate_oblivious_pseudo_random_bounded_and_re_randomize<'a, RRD: Into<ReRandomizationMode<'a>>>( seed: impl OprfSeed, random_bits_count: u64, re_randomization_mode: RRD, prf_re_randomization_context: &PrfReRandomizationContext, ) -> Result<Self>

pub fn generate_oblivious_pseudo_random_custom_range( seed: impl OprfSeed, range: &RangeForRandom, max_distance: Option<f64>, ) -> Self

pub fn get_generate_oblivious_pseudo_random_bounded_size_on_gpu() -> u64

pub fn generate_oblivious_pseudo_random_custom_range_and_re_randomize<'a, RRD: Into<ReRandomizationMode<'a>>>( seed: impl OprfSeed, range: &RangeForRandom, max_distance: Option<f64>, re_randomization_mode: RRD, prf_re_randomization_context: &PrfReRandomizationContext, ) -> Result<Self>

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

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

pub fn from_raw_parts( ciphertext: RadixCiphertext, id: Id, tag: Tag, re_randomization_metadata: ReRandomizationMetadata, ) -> 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 contains(cts: &[Self], value: &Self) -> FheBool

§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 get_match_value_size_on_gpu<Clear>( &self, matches: &MatchValues<Clear>, ) -> Result<u64>where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>,

§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 get_match_value_or_size_on_gpu<Clear>( &self, matches: &MatchValues<Clear>, or_value: Clear, ) -> Result<u64>where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>,

§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>,

pub fn re_randomization_metadata(&self) -> &ReRandomizationMetadata

pub fn re_randomization_metadata_mut(&mut self) -> &mut ReRandomizationMetadata

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

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

Trait Implementations§

impl Add<&FheUint<FheUint2Id>> for u8

type Output = FheUint<FheUint2Id>

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

impl Add<&FheUint<FheUint2Id>> for &u8

type Output = FheUint<FheUint2Id>

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

impl Add<&FheUint<FheUint4Id>> for u8

type Output = FheUint<FheUint4Id>

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

impl Add<&FheUint<FheUint4Id>> for &u8

type Output = FheUint<FheUint4Id>

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

impl Add<&FheUint<FheUint6Id>> for u8

type Output = FheUint<FheUint6Id>

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 get_match_value_size_on_gpu<Clear>( &self, matches: &MatchValues<Clear>, ) -> Result<u64>
where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>,

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 get_match_value_or_size_on_gpu<Clear>( &self, matches: &MatchValues<Clear>, or_value: Clear, ) -> Result<u64>
where Clear: UnsignedInteger + DecomposableInto<u64> + CastInto<usize>,

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,