concrete_core/backends/default/implementation/engines/default_engine/
cleartext_encoding.rs

1use crate::commons::crypto::encoding::Encoder;
2use crate::prelude::{
3    CleartextEncodingEngine, CleartextEncodingError, CleartextF64, DefaultEngine, DefaultError,
4    FloatEncoder, Plaintext32, Plaintext64,
5};
6
7/// # Description:
8/// Implementation of [`CleartextEncodingEngine`] for [`DefaultEngine`] that encodes 64 bits
9/// floating point numbers to 32 bits integers.
10impl CleartextEncodingEngine<FloatEncoder, CleartextF64, Plaintext32> for DefaultEngine {
11    /// # Example:
12    /// ```
13    /// use concrete_core::prelude::*;
14    /// # use std::error::Error;
15    /// # fn main() -> Result<(), Box<dyn Error>> {
16    /// // Unix seeder must be given a secret input.
17    /// // Here we just give it 0, which is totally unsafe.
18    /// const UNSAFE_SECRET: u128 = 0;
19    /// let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
20    /// let encoder = engine.create_encoder_from(&FloatEncoderMinMaxConfig {
21    ///     min: 0.,
22    ///     max: 10.,
23    ///     nb_bit_precision: 8,
24    ///     nb_bit_padding: 1,
25    /// })?;
26    /// let cleartext: CleartextF64 = engine.create_cleartext_from(&5.)?;
27    /// let plaintext: Plaintext32 = engine.encode_cleartext(&encoder, &cleartext)?;
28    /// #
29    /// # Ok(())
30    /// # }
31    /// ```
32    fn encode_cleartext(
33        &mut self,
34        encoder: &FloatEncoder,
35        cleartext: &CleartextF64,
36    ) -> Result<Plaintext32, CleartextEncodingError<Self::EngineError>> {
37        if encoder.0.is_message_out_of_range(cleartext.0 .0) {
38            return Err(CleartextEncodingError::Engine(
39                DefaultError::FloatEncoderMessageOutsideInterval,
40            ));
41        }
42        Ok(unsafe { self.encode_cleartext_unchecked(encoder, cleartext) })
43    }
44
45    unsafe fn encode_cleartext_unchecked(
46        &mut self,
47        encoder: &FloatEncoder,
48        cleartext: &CleartextF64,
49    ) -> Plaintext32 {
50        Plaintext32(encoder.0.encode(cleartext.0))
51    }
52}
53
54/// # Description:
55/// Implementation of [`CleartextEncodingEngine`] for [`DefaultEngine`] that encodes 64 bits
56/// floating point numbers to 32 bits integers.
57impl CleartextEncodingEngine<FloatEncoder, CleartextF64, Plaintext64> for DefaultEngine {
58    /// # Example:
59    /// ```
60    /// use concrete_core::prelude::*;
61    /// # use std::error::Error;
62    /// # fn main() -> Result<(), Box<dyn Error>> {
63    /// // Unix seeder must be given a secret input.
64    /// // Here we just give it 0, which is totally unsafe.
65    /// const UNSAFE_SECRET: u128 = 0;
66    /// let mut engine = DefaultEngine::new(Box::new(UnixSeeder::new(UNSAFE_SECRET)))?;
67    /// let encoder = engine.create_encoder_from(&FloatEncoderMinMaxConfig {
68    ///     min: 0.,
69    ///     max: 10.,
70    ///     nb_bit_precision: 8,
71    ///     nb_bit_padding: 1,
72    /// })?;
73    /// let cleartext: CleartextF64 = engine.create_cleartext_from(&5.)?;
74    /// let plaintext: Plaintext64 = engine.encode_cleartext(&encoder, &cleartext)?;
75    /// #
76    /// # Ok(())
77    /// # }
78    /// ```
79    fn encode_cleartext(
80        &mut self,
81        encoder: &FloatEncoder,
82        cleartext: &CleartextF64,
83    ) -> Result<Plaintext64, CleartextEncodingError<Self::EngineError>> {
84        if encoder.0.is_message_out_of_range(cleartext.0 .0) {
85            return Err(CleartextEncodingError::Engine(
86                DefaultError::FloatEncoderMessageOutsideInterval,
87            ));
88        }
89        Ok(unsafe { self.encode_cleartext_unchecked(encoder, cleartext) })
90    }
91
92    unsafe fn encode_cleartext_unchecked(
93        &mut self,
94        encoder: &FloatEncoder,
95        cleartext: &CleartextF64,
96    ) -> Plaintext64 {
97        Plaintext64(encoder.0.encode(cleartext.0))
98    }
99}