concrete-core 0.1.6

Concrete is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.
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
110
111
112
113
114
115
116
117

use fftw::array::AlignedVec;

/// A trait allowing to extract a slice from a tensor.
///
/// This trait is one of the two traits which allows to use [`Tensor`](super::Tensor) whith any data
/// container.
/// This trait basically allows to extract a slice `&[T]` out of a container, to implement
/// operations directly on the slice:
/// ```rust,ignore
/// // Implementing AsSlice for Vec<T>
/// impl<Element> AsSlice for Vec<Element> {
///     type Element = Element;
///     fn as_slice(&self) -> &[Element] {
///         self.as_slice()
///     }
/// }
/// ```
/// It is akin to the [`std::borrow::Borrow`] trait from the standard library, but it is local to
/// this crate (which makes this little explanation possible), and the scalar type is an associated
/// type. Having an associated type instead of a generic type, tends to make signatures a little
/// leaner.
///
/// Finally, you should note that we have a blanket implementation that implements `AsView` for
/// `Tensor<Cont>` where `Cont` is itself `AsView`:
/// ```rust,ignore
/// impl<Cont> AsView for Tensor<Cont>
/// where
///     Cont: AsView,
/// {
///     type Scalar = Cont::Scalar;
///     fn as_view(&self) -> &[Self::Scalar] {
///         // implementation
///     }
/// }
/// ```
/// This is blanket implementation is used by the methods of the `Tensor` structure for instance.
pub trait AsRefSlice {
    /// The type of the elements of the collection.
    type Element;
    /// Returns a slice from the container.
    fn as_slice(&self) -> &[Self::Element];
}

impl<Element> AsRefSlice for Vec<Element> {
    type Element = Element;
    fn as_slice(&self) -> &[Element] {
        self.as_slice()
    }
}

impl<Element> AsRefSlice for [Element; 1] {
    type Element = Element;
    fn as_slice(&self) -> &[Element] {
        &self[..]
    }
}

impl<Element> AsRefSlice for &[Element] {
    type Element = Element;
    fn as_slice(&self) -> &[Element] {
        self
    }
}

impl<Element> AsRefSlice for &mut [Element] {
    type Element = Element;
    fn as_slice(&self) -> &[Element] {
        self
    }
}

impl<Element> AsRefSlice for AlignedVec<Element> {
    type Element = Element;
    fn as_slice(&self) -> &[Element] {
        self.as_slice()
    }
}

/// A trait allowing to extract a mutable slice from a tensor.
///
/// The logic is the same as for the `AsRefTensor`, but here, it allows to access mutable slices
/// instead. See the [`AsRefTensor`](super::AsRefTensor) documentation for a more detailed
/// explanation of the logic.
pub trait AsMutSlice: AsRefSlice<Element = <Self as AsMutSlice>::Element> {
    /// The type of the elements of the collection
    type Element;
    /// Returns a mutable slice from the container.
    fn as_mut_slice(&mut self) -> &mut [<Self as AsMutSlice>::Element];
}

impl<Element> AsMutSlice for Vec<Element> {
    type Element = Element;
    fn as_mut_slice(&mut self) -> &mut [Element] {
        self.as_mut_slice()
    }
}

impl<Element> AsMutSlice for [Element; 1] {
    type Element = Element;
    fn as_mut_slice(&mut self) -> &mut [Element] {
        &mut self[..]
    }
}

impl<Element> AsMutSlice for &mut [Element] {
    type Element = Element;
    fn as_mut_slice(&mut self) -> &mut [Element] {
        self
    }
}

impl<Element> AsMutSlice for AlignedVec<Element> {
    type Element = Element;
    fn as_mut_slice(&mut self) -> &mut [Element] {
        self.as_slice_mut()
    }
}