cralgebra 0.2.1

A fast crypto algebra library
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

#[cfg(test)]
extern crate test;

use std::ops::Add;

#[const_trait]
pub trait AddCost<Rhs = Self>: Add<Rhs> {
    fn add_cost() -> f64;
}

#[bench]
fn add_u64_bench(bencher: &mut test::Bencher) {
    let a = test::black_box(0x1234567887654321_u64);
    let b = test::black_box(0x9876543223456789_u64);
    bencher.iter(|| test::black_box(a + b));
}

impl const AddCost<u8> for u8 {
    fn add_cost() -> f64 {
        0.5
    }
}

impl const AddCost<u16> for u16 {
    fn add_cost() -> f64 {
        0.5
    }
}

impl const AddCost<u32> for u32 {
    fn add_cost() -> f64 {
        1.0
    }
}

impl const AddCost<u64> for u64 {
    fn add_cost() -> f64 {
        0.5
    }
}

#[bench]
fn add_u128_bench(bencher: &mut test::Bencher) {
    let a = test::black_box(0x12345678876543219876543223456789_u128);
    let b = test::black_box(0x98765432234567891234567887654321_u128);
    bencher.iter(|| test::black_box(a + b));
}

impl const AddCost<u128> for u128 {
    fn add_cost() -> f64 {
        7.0
    }
}

use std::ops::Mul;

#[const_trait]
pub trait MulCost<Rhs = Self>: Mul<Rhs> {
    fn mul_cost() -> f64;
}

#[bench]
fn mul_u64_bench(bencher: &mut test::Bencher) {
    let a = test::black_box(0x1234567887654321_u64);
    let b = test::black_box(0x9876543223456789_u64);
    bencher.iter(|| test::black_box(a.wrapping_mul(b)));
}

impl const MulCost<u8> for u8 {
    fn mul_cost() -> f64 {
        1.0
    }
}

impl const MulCost<u16> for u16 {
    fn mul_cost() -> f64 {
        1.0
    }
}

impl const MulCost<u32> for u32 {
    fn mul_cost() -> f64 {
        1.0
    }
}

impl const MulCost<u64> for u64 {
    fn mul_cost() -> f64 {
        1.0
    }
}

#[bench]
fn mul_u128_bench(bencher: &mut test::Bencher) {
    let a = test::black_box(0x12345678876543219876543223456789_u128);
    let b = test::black_box(0x98765432234567891234567887654321_u128);
    bencher.iter(|| test::black_box(a.wrapping_mul(b)));
}

impl const MulCost<u128> for u128 {
    fn mul_cost() -> f64 {
        7.0
    }
}

use std::ops::{Div, Rem};

#[const_trait]
pub trait DivCost<Rhs = Self>: Div<Rhs> + Rem<Rhs> {
    fn div_cost() -> f64;
}

#[bench]
fn div_u64_bench(bencher: &mut test::Bencher) {
    let a = test::black_box(0x1234567887654321_u64);
    let b = test::black_box(0x9876543223456789_u64);
    bencher.iter(|| test::black_box(a % b));
}

impl const DivCost<u8> for u8 {
    fn div_cost() -> f64 {
        1.0
    }
}

impl const DivCost<u16> for u16 {
    fn div_cost() -> f64 {
        1.0
    }
}

impl const DivCost<u32> for u32 {
    fn div_cost() -> f64 {
        1.0
    }
}

impl const DivCost<u64> for u64 {
    fn div_cost() -> f64 {
        1.0
    }
}

#[bench]
fn div_u128_bench(bencher: &mut test::Bencher) {
    let a = test::black_box(0x12345678876543219876543223456789_u128);
    let b = test::black_box(0x98765432234567891234567887654321_u128);
    bencher.iter(|| test::black_box(a % b));
}

impl const DivCost<u128> for u128 {
    fn div_cost() -> f64 {
        7.0
    }
}