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

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

Implementations§

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

Available on crate feature integer only.

Source

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

Available on crate feature integer only.

Source

pub fn num_bits() -> usize

Available on crate feature integer only.

Source

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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)

Available on crate feature integer only.

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,

Available on crate feature integer only.

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,

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

Same as Self::if_then_else but with a different name

Source

pub fn re_randomization_metadata(&self) -> &ReRandomizationMetadata

Available on crate feature integer only.

Source

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

Available on crate feature integer only.

Source §

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

Source

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

Available on crate feature integer only.

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

Source §

Performs a bitwise ‘and’ 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(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

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

§Example

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

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

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

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

Performs a bitwise ‘or’ 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(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

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

§Example

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

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

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

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

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

Available on crate feature integer only.

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,

Available on crate feature integer only.

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 §

Performs a bitwise ‘xor’ 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(3u16, &client_key);
let b = FheUint16::encrypt(37849u16, &client_key);

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

§Example

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

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

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

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

Available on crate feature integer only.

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,

Available on crate feature integer only.

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,

Available on crate feature integer only.

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>

Available on crate feature integer only.

Source §

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

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

Deserialize this value from the given Serde deserializer. Read more

Source §

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

Available on crate feature integer only.

Source §

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

Divides two FheUint and returns the quotient

§Note

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

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

This behaviour should not be relied on.

§Example

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

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

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

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

§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> DivRem<&FheUint<Id>> for FheUint<Id>
where Id: FheUintId,

Available on crate feature integer only.

Source §

type Output = (FheUint<Id>, FheUint<Id>)

Source §

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

Source §

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

Available on crate feature integer only.

Source §

fn div_rem(self, rhs: Self) -> Self::Output

Computes the quotient and remainder between two FheUint

If you need both the quotient and remainder, then div_rem is better than computing them separately using / and %.

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

Source §

type Output = (FheUint<Id>, FheUint<Id>)

Source §

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

Available on crate feature integer only.

Source §

Available on crate feature integer only.

Source §

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

Decrypts a FheUint to an unsigned type.

The unsigned type has to be explicit.

§Example

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

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

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

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

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Source §

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

Source §

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

Source §

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

Source §

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

Available on crate features integer and gpu only.

fn dot_product(bools: &[FheBool], clears: &[Clear]) -> Self

Performs a dot product between a slice of encrypted booleans and a slice of clear unsigned integers.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Source §

type Output = FheUint<Id>

Source §

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

Available on crate feature integer only.

Source §

type Output = FheUint<Id>

Source §

fn set_re_randomization_metadata(&mut self, meta: ReRandomizationMetadata)

Available on crate feature gpu only.

Source §

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

Available on crate feature integer only.

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 features integer and gpu only.

Source §

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

Source §

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

Source §

Multiplies 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_mul(37849u16));

Source §

The resulting type after applying the ! operator.

Source §

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

Available on crate feature integer only.

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,

Available on crate feature integer only.

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,

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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,

Available on crate feature integer only.

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,

Available on crate feature integer only.

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

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> OverflowingSub<&FheUint<Id>> for FheUint<Id>
where Id: FheUintId,

Available on crate feature integer only.

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

Available on crate feature integer only.

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

Available on crate feature integer only.

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: FheUintId> ParameterSetConformant for FheUint<Id>

Available on crate feature integer only.

Source §

type ParameterSet = FheUintConformanceParams<Id>

Source §

fn is_conformant(&self, params: &FheUintConformanceParams<Id>) -> bool

Source §

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

Available on crate feature integer only.

Source §

fn add_to_re_randomization_context(&self, context: &mut ReRandomizationContext)

Source §

fn re_randomize( &mut self, compact_public_key: &CompactPublicKey, seed: ReRandomizationSeed, ) -> Result<()>

Re-randomize the ciphertext using the provided public key and seed. Read more

Source §

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

Available on crate feature integer only.

Source §

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

Divides two FheUint and returns the remainder

§Note

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

When the divisor is 0, the returned 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);

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

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,

Available on crate feature integer only.

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

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,

Available on crate feature integer only.

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

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

fn scalar_select(&self, value_true: Lhs, value_false: Rhs) -> Self::Output

Source §

fn scalar_cmux(&self, value_true: Lhs, value_false: Rhs) -> Self::Output

Source §

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

Available on crate feature integer only.

Source §

fn scalar_if_then_else( &self, then_value: Scalar, else_value: &FheUint<Id>, ) -> 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 = u32::MIN;
let b = FheUint32::encrypt(u32::MAX, &client_key);
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::MIN);

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

Source §

type Output = FheUint<Id>

Source §

fn scalar_select(&self, value_true: Lhs, value_false: Rhs) -> Self::Output

Source §

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

Performs the <<= 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 <<= &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,

Available on crate feature integer only.

Source §

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

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,

Available on crate feature integer only.

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,

Available on crate feature integer only.

Source §

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

Performs the <<= operation. Read more

The resulting type after applying the >> operator.

Source §

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

Available on crate feature integer only.

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

Source §

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

Performs the >>= 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 >>= &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,

Available on crate feature integer only.

Source §

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

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,

Available on crate feature integer only.

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,

Available on crate feature integer only.

Source §

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

Performs the >>= operation. Read more

Source §

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 §

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

Source §

impl<Id: FheUintId> Upgrade<FheUint<Id>> for FheUintV1<Id>

Available on crate feature integer only.

Source §

type Error = Infallible

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 §

impl<Id: FheUintId> VersionsDispatch<FheUint<Id>> for FheUintVersions<Id>
where FheUintV0<Id>: Version + Upgrade<FheUintV1<Id>>, FheUintV1<Id>: Version + Upgrade<FheUint<Id>>, FheUint<Id>: Version,

Available on crate feature integer only.

Source §

type Ref<'vers> = FheUintVersionsDispatch<'vers, Id> where Id: 'vers

Source §

type Owned = FheUintVersionsDispatchOwned<Id>

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 §

FheUint

Struct FheUint Copy 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, 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 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>,

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<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<FheUint104Id>> for &u128

type Output = FheUint<FheUint104Id>

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

impl Add<&FheUint<FheUint104Id>> for u128

type Output = FheUint<FheUint104Id>

fn add(self, rhs: &FheUint104) -> 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<FheUint112Id>> for &u128

type Output = FheUint<FheUint112Id>

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

impl Add<&FheUint<FheUint112Id>> for u128

type Output = FheUint<FheUint112Id>

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,