tfhe 1.6.1

TFHE-rs is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use crate::array::cpu::ClearContainer;
use crate::array::{ClearArray, DynDimensions};
use crate::high_level_api::array::traits::{
    ArrayBackend, BackendDataContainer, ClearArithmeticArrayBackend, ClearBitwiseArrayBackend,
    HasClear,
};
use crate::high_level_api::array::FheArrayBase;
use crate::FheId;
use std::ops::{Add, BitAnd};

macro_rules! impl_other_binary_ops_variants {
    (
        $trait_name:ident($trait_method:ident) => $backend_trait:ident($backend_method:ident)
    ) => {
        impl<'a, C, Clear, Id> $trait_name<ClearArray<Clear>> for FheArrayBase<C, Id>
        where
            Id: FheId,
            Clear: Copy,
            FheArrayBase<C, Id>: HasClear<Clear = Clear>,
            C: BackendDataContainer,
            C::Backend: $backend_trait<Clear>,
        {
            type Output = FheArrayBase<<C::Backend as ArrayBackend>::Owned, Id>;

            fn $trait_method(self, rhs: ClearArray<Clear>) -> Self::Output {
                if !self.has_same_shape(&rhs) {
                    panic!("Array operands do not have the same shape");
                }
                let lhs_slice = self.as_tensor_slice();
                let rhs_slice = rhs.as_tensor_slice().map(ClearContainer::into_inner);
                let inner = C::Backend::$backend_method(lhs_slice, rhs_slice);
                let resulting_shape = DynDimensions::from(self.shape().to_vec());
                FheArrayBase::new(inner, resulting_shape)
            }
        }

        impl<'a, C, Clear, Id> $trait_name<ClearArray<Clear>> for &'a FheArrayBase<C, Id>
        where
            Id: FheId,
            Clear: Copy,

            FheArrayBase<C, Id>: HasClear<Clear = Clear>,
            C: BackendDataContainer,
            C::Backend: $backend_trait<Clear>,
        {
            type Output = FheArrayBase<<C::Backend as ArrayBackend>::Owned, Id>;

            fn $trait_method(self, rhs: ClearArray<Clear>) -> Self::Output {
                if !self.has_same_shape(&rhs) {
                    panic!("Array operands do not have the same shape");
                }
                let lhs_slice = self.as_tensor_slice();
                let rhs_slice = rhs.as_tensor_slice().map(ClearContainer::into_inner);
                let inner = C::Backend::$backend_method(lhs_slice, rhs_slice);
                let resulting_shape = DynDimensions::from(self.shape().to_vec());
                FheArrayBase::new(inner, resulting_shape)
            }
        }

        impl<'a, C, Clear, Id> $trait_name<&'a ClearArray<Clear>> for FheArrayBase<C, Id>
        where
            Id: FheId,
            Clear: Copy,

            FheArrayBase<C, Id>: HasClear<Clear = Clear>,
            C: BackendDataContainer,
            C::Backend: $backend_trait<Clear>,
        {
            type Output = FheArrayBase<<C::Backend as ArrayBackend>::Owned, Id>;

            fn $trait_method(self, rhs: &'a ClearArray<Clear>) -> Self::Output {
                if !self.has_same_shape(rhs) {
                    panic!("Array operands do not have the same shape");
                }
                let lhs_slice = self.as_tensor_slice();
                let rhs_slice = rhs.as_tensor_slice().map(ClearContainer::into_inner);
                let inner = C::Backend::$backend_method(lhs_slice, rhs_slice);
                let resulting_shape = DynDimensions::from(self.shape().to_vec());
                FheArrayBase::new(inner, resulting_shape)
            }
        }

        impl<'a, 'b, C, Clear, Id> $trait_name<&'a ClearArray<Clear>> for &'b FheArrayBase<C, Id>
        where
            Id: FheId,
            Clear: Copy,

            FheArrayBase<C, Id>: HasClear<Clear = Clear>,
            C: BackendDataContainer,
            C::Backend: $backend_trait<Clear>,
        {
            type Output = FheArrayBase<<C::Backend as ArrayBackend>::Owned, Id>;

            fn $trait_method(self, rhs: &'a ClearArray<Clear>) -> Self::Output {
                if !self.has_same_shape(rhs) {
                    panic!("Array operands do not have the same shape");
                }
                let lhs_slice = self.as_tensor_slice();
                let rhs_slice = rhs.as_tensor_slice().map(ClearContainer::into_inner);
                let inner = C::Backend::$backend_method(lhs_slice, rhs_slice);
                let resulting_shape = DynDimensions::from(self.shape().to_vec());
                FheArrayBase::new(inner, resulting_shape)
            }
        }
    };
}

impl_other_binary_ops_variants!(Add(add) => ClearArithmeticArrayBackend(add_slices));
impl_other_binary_ops_variants!(BitAnd(bitand) => ClearBitwiseArrayBackend(bitand_slice));