scale_std 0.1.2

datastructures and algorithms to be run on the SCALE engine
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

// Copyright (c) 2021, COSIC-KU Leuven, Kasteelpark Arenberg 10, bus 2452, B-3001 Leuven-Heverlee, Belgium.
// Copyright (c) 2021, Cosmian Tech SAS, 53-55 rue La Boétie, Paris, France.

use crate::array::*;
use crate::bit_protocols::*;
use crate::integer::*;
use crate::slice::*;
use scale::*;

/**************************************
 * Helper routines for floating point *
 **************************************/

/* Input an integer of size K,
 * Output float tuple with mantissa of size L
 */
#[allow(non_snake_case)]
pub fn Clear_Int2Fl<const K: u64, const L: u64>(
    a_int: ClearInteger<K>,
    _: ConstU64<L>,
) -> Array<ClearModp, 5>
where
    ConstU64<{ K - 1 }>: ,
{
    let s = a_int.ltz();
    let z = a_int.eqz();
    let a = a_int.rep();
    let aa = (ClearModp::from(1) - s - s) * a;
    let vec_a: Slice<ClearModp> = Slice::bit_decomposition_ClearModp(aa, K - 1);
    let rev_a = vec_a.reverse();
    let vec_b = rev_a.PreOr();
    let one = ClearModp::from(1_i64);
    let mut v = one;
    let mut p = ClearModp::from((K - 1) as i64);
    let mut twop = ClearModp::from(1_i64);
    for i in 0..K - 1 {
        v = v + twop * (one - *vec_b.get_unchecked(i));
        p = p - *vec_b.get_unchecked(i);
        twop = twop + twop;
    }
    p = -p;
    v = a * v;
    if (K - 1) > L {
        let mut v_int: ClearInteger<{ K - 1 }> = ClearInteger::from(v);
        v_int = v_int.Trunc(K - L - 1, false);
        v = v_int.rep();
    } else {
        v = v * modp_two_power(L - K + 1);
    }
    p = (p + ClearModp::from((K - L - 1) as i64)) * (ClearModp::from(1) - z);
    let err = ClearModp::from(0_i64);
    let mut ans: Array<ClearModp, 5> = Array::uninitialized();
    ans.set(0, &v);
    ans.set(1, &p);
    ans.set(2, &z);
    ans.set(3, &s);
    ans.set(4, &err);
    ans
}

/* Input an integer of size K,
 * Output float tuple with mantissa of size L
 */
#[allow(non_snake_case)]
pub fn Secret_Int2Fl<const K: u64, const L: u64, const KAPPA: u64>(
    a_int: SecretInteger<K, KAPPA>,
    _: ConstU64<L>,
) -> Array<SecretModp, 5>
where
    ConstU64<{ K - 1 }>: ,
{
    let s = a_int.ltz();
    let z = a_int.eqz();
    let a = a_int.rep();
    let aa = (SecretModp::from(1) - s - s) * a;
    let vec_a = BitDec::<{ K - 1 }, { K - 1 }, KAPPA>(aa);
    let rev_a = vec_a.reverse();
    let vec_b = rev_a.PreOr();
    let one = SecretModp::from(1_i64);
    let mut v = one;
    let mut p = SecretModp::from((K - 1) as i64);
    let mut twop = SecretModp::from(1_i64);
    for i in 0..K - 1 {
        v = v + twop * (one - *vec_b.get_unchecked(i));
        p = p - *vec_b.get_unchecked(i);
        twop = twop + twop;
    }
    p = -p;
    v = a * v;
    if (K - 1) > L {
        let mut v_int: SecretInteger<{ K - 1 }, KAPPA> = SecretInteger::from(v);
        v_int = v_int.Trunc(K - L - 1, false);
        v = v_int.rep();
    } else {
        v = v * modp_two_power(L - K + 1);
    }
    p = (p + SecretModp::from((K - L - 1) as i64)) * (SecretModp::from(1) - z);
    let err = SecretModp::from(0_i64);
    let mut ans: Array<SecretModp, 5> = Array::uninitialized();
    ans.set(0, &v);
    ans.set(1, &p);
    ans.set(2, &z);
    ans.set(3, &s);
    ans.set(4, &err);
    ans
}