Electroneum
multiexp.cpp File Reference
#include "gtest/gtest.h"
#include "crypto/crypto.h"
#include "ringct/rctOps.h"
#include "ringct/multiexp.h"
Include dependency graph for multiexp.cpp:

Go to the source code of this file.

Functions

 TEST (multiexp, bos_coster_empty)
 
 TEST (multiexp, straus_empty)
 
 TEST (multiexp, pippenger_empty)
 
 TEST (multiexp, bos_coster_zero_and_non_zero)
 
 TEST (multiexp, straus_zero_and_non_zero)
 
 TEST (multiexp, pippenger_zero_and_non_zero)
 
 TEST (multiexp, bos_coster_pow2_scalar)
 
 TEST (multiexp, straus_pow2_scalar)
 
 TEST (multiexp, pippenger_pow2_scalar)
 
 TEST (multiexp, bos_coster_only_zeroes)
 
 TEST (multiexp, straus_only_zeroes)
 
 TEST (multiexp, pippenger_only_zeroes)
 
 TEST (multiexp, bos_coster_only_identities)
 
 TEST (multiexp, straus_only_identities)
 
 TEST (multiexp, pippenger_only_identities)
 
 TEST (multiexp, bos_coster_random)
 
 TEST (multiexp, straus_random)
 
 TEST (multiexp, pippenger_random)
 
 TEST (multiexp, straus_cached)
 
 TEST (multiexp, pippenger_cached)
 

Function Documentation

◆ TEST() [1/20]

TEST ( multiexp  ,
bos_coster_empty   
)

Definition at line 65 of file multiexp.cpp.

66 {
67  std::vector<rct::MultiexpData> data;
68  data.push_back({rct::zero(), get_p3(rct::identity())});
69  ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
70 }
rct::key bos_coster_heap_conv_robust(std::vector< MultiexpData > data)
key identity()
Definition: rctOps.h:73
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
key zero()
Definition: rctOps.h:70
Here is the call graph for this function:

◆ TEST() [2/20]

TEST ( multiexp  ,
straus_empty   
)

Definition at line 72 of file multiexp.cpp.

73 {
74  std::vector<rct::MultiexpData> data;
75  data.push_back({rct::zero(), get_p3(rct::identity())});
76  ASSERT_TRUE(basic(data) == straus(data));
77 }
rct::key straus(const std::vector< MultiexpData > &data, const std::shared_ptr< straus_cached_data > &cache=NULL, size_t STEP=0)
key identity()
Definition: rctOps.h:73
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
key zero()
Definition: rctOps.h:70
Here is the call graph for this function:

◆ TEST() [3/20]

TEST ( multiexp  ,
pippenger_empty   
)

Definition at line 79 of file multiexp.cpp.

80 {
81  std::vector<rct::MultiexpData> data;
82  data.push_back({rct::zero(), get_p3(rct::identity())});
83  ASSERT_TRUE(basic(data) == pippenger(data));
84 }
rct::key pippenger(const std::vector< MultiexpData > &data, const std::shared_ptr< pippenger_cached_data > &cache=NULL, size_t cache_size=0, size_t c=0)
key identity()
Definition: rctOps.h:73
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
key zero()
Definition: rctOps.h:70
Here is the call graph for this function:

◆ TEST() [4/20]

TEST ( multiexp  ,
bos_coster_zero_and_non_zero   
)

Definition at line 86 of file multiexp.cpp.

87 {
88  std::vector<rct::MultiexpData> data;
89  data.push_back({rct::zero(), get_p3(TESTPOINT)});
90  data.push_back({TESTSCALAR, get_p3(TESTPOINT)});
91  ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
92 }
rct::key bos_coster_heap_conv_robust(std::vector< MultiexpData > data)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
key zero()
Definition: rctOps.h:70
Here is the call graph for this function:

◆ TEST() [5/20]

TEST ( multiexp  ,
straus_zero_and_non_zero   
)

Definition at line 94 of file multiexp.cpp.

95 {
96  std::vector<rct::MultiexpData> data;
97  data.push_back({rct::zero(), get_p3(TESTPOINT)});
98  data.push_back({TESTSCALAR, get_p3(TESTPOINT)});
99  ASSERT_TRUE(basic(data) == straus(data));
100 }
rct::key straus(const std::vector< MultiexpData > &data, const std::shared_ptr< straus_cached_data > &cache=NULL, size_t STEP=0)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
key zero()
Definition: rctOps.h:70
Here is the call graph for this function:

◆ TEST() [6/20]

TEST ( multiexp  ,
pippenger_zero_and_non_zero   
)

Definition at line 102 of file multiexp.cpp.

103 {
104  std::vector<rct::MultiexpData> data;
105  data.push_back({rct::zero(), get_p3(TESTPOINT)});
106  data.push_back({TESTSCALAR, get_p3(TESTPOINT)});
107  ASSERT_TRUE(basic(data) == pippenger(data));
108 }
rct::key pippenger(const std::vector< MultiexpData > &data, const std::shared_ptr< pippenger_cached_data > &cache=NULL, size_t cache_size=0, size_t c=0)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
key zero()
Definition: rctOps.h:70
Here is the call graph for this function:

◆ TEST() [7/20]

TEST ( multiexp  ,
bos_coster_pow2_scalar   
)

Definition at line 110 of file multiexp.cpp.

111 {
112  std::vector<rct::MultiexpData> data;
113  data.push_back({TESTPOW2SCALAR, get_p3(TESTPOINT)});
114  data.push_back({TESTSMALLSCALAR, get_p3(TESTPOINT)});
115  ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
116 }
rct::key bos_coster_heap_conv_robust(std::vector< MultiexpData > data)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865

◆ TEST() [8/20]

TEST ( multiexp  ,
straus_pow2_scalar   
)

Definition at line 118 of file multiexp.cpp.

119 {
120  std::vector<rct::MultiexpData> data;
121  data.push_back({TESTPOW2SCALAR, get_p3(TESTPOINT)});
122  data.push_back({TESTSMALLSCALAR, get_p3(TESTPOINT)});
123  ASSERT_TRUE(basic(data) == straus(data));
124 }
rct::key straus(const std::vector< MultiexpData > &data, const std::shared_ptr< straus_cached_data > &cache=NULL, size_t STEP=0)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865

◆ TEST() [9/20]

TEST ( multiexp  ,
pippenger_pow2_scalar   
)

Definition at line 126 of file multiexp.cpp.

127 {
128  std::vector<rct::MultiexpData> data;
129  data.push_back({TESTPOW2SCALAR, get_p3(TESTPOINT)});
130  data.push_back({TESTSMALLSCALAR, get_p3(TESTPOINT)});
131  ASSERT_TRUE(basic(data) == pippenger(data));
132 }
rct::key pippenger(const std::vector< MultiexpData > &data, const std::shared_ptr< pippenger_cached_data > &cache=NULL, size_t cache_size=0, size_t c=0)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865

◆ TEST() [10/20]

TEST ( multiexp  ,
bos_coster_only_zeroes   
)

Definition at line 134 of file multiexp.cpp.

135 {
136  std::vector<rct::MultiexpData> data;
137  for (int n = 0; n < 16; ++n)
138  data.push_back({rct::zero(), get_p3(TESTPOINT)});
139  ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
140 }
rct::key bos_coster_heap_conv_robust(std::vector< MultiexpData > data)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865

◆ TEST() [11/20]

TEST ( multiexp  ,
straus_only_zeroes   
)

Definition at line 142 of file multiexp.cpp.

143 {
144  std::vector<rct::MultiexpData> data;
145  for (int n = 0; n < 16; ++n)
146  data.push_back({rct::zero(), get_p3(TESTPOINT)});
147  ASSERT_TRUE(basic(data) == straus(data));
148 }
rct::key straus(const std::vector< MultiexpData > &data, const std::shared_ptr< straus_cached_data > &cache=NULL, size_t STEP=0)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865

◆ TEST() [12/20]

TEST ( multiexp  ,
pippenger_only_zeroes   
)

Definition at line 150 of file multiexp.cpp.

151 {
152  std::vector<rct::MultiexpData> data;
153  for (int n = 0; n < 16; ++n)
154  data.push_back({rct::zero(), get_p3(TESTPOINT)});
155  ASSERT_TRUE(basic(data) == pippenger(data));
156 }
rct::key pippenger(const std::vector< MultiexpData > &data, const std::shared_ptr< pippenger_cached_data > &cache=NULL, size_t cache_size=0, size_t c=0)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865

◆ TEST() [13/20]

TEST ( multiexp  ,
bos_coster_only_identities   
)

Definition at line 158 of file multiexp.cpp.

159 {
160  std::vector<rct::MultiexpData> data;
161  for (int n = 0; n < 16; ++n)
162  data.push_back({TESTSCALAR, get_p3(rct::identity())});
163  ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
164 }
rct::key bos_coster_heap_conv_robust(std::vector< MultiexpData > data)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865

◆ TEST() [14/20]

TEST ( multiexp  ,
straus_only_identities   
)

Definition at line 166 of file multiexp.cpp.

167 {
168  std::vector<rct::MultiexpData> data;
169  for (int n = 0; n < 16; ++n)
170  data.push_back({TESTSCALAR, get_p3(rct::identity())});
171  ASSERT_TRUE(basic(data) == straus(data));
172 }
rct::key straus(const std::vector< MultiexpData > &data, const std::shared_ptr< straus_cached_data > &cache=NULL, size_t STEP=0)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865

◆ TEST() [15/20]

TEST ( multiexp  ,
pippenger_only_identities   
)

Definition at line 174 of file multiexp.cpp.

175 {
176  std::vector<rct::MultiexpData> data;
177  for (int n = 0; n < 16; ++n)
178  data.push_back({TESTSCALAR, get_p3(rct::identity())});
179  ASSERT_TRUE(basic(data) == pippenger(data));
180 }
rct::key pippenger(const std::vector< MultiexpData > &data, const std::shared_ptr< pippenger_cached_data > &cache=NULL, size_t cache_size=0, size_t c=0)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865

◆ TEST() [16/20]

TEST ( multiexp  ,
bos_coster_random   
)

Definition at line 182 of file multiexp.cpp.

183 {
184  std::vector<rct::MultiexpData> data;
185  for (int n = 0; n < 32; ++n)
186  {
187  data.push_back({rct::skGen(), get_p3(rct::scalarmultBase(rct::skGen()))});
188  ASSERT_TRUE(basic(data) == bos_coster_heap_conv_robust(data));
189  }
190 }
void skGen(key &sk)
Definition: rctOps.cpp:253
void scalarmultBase(key &aG, const key &a)
Definition: rctOps.cpp:350
rct::key bos_coster_heap_conv_robust(std::vector< MultiexpData > data)
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
Here is the call graph for this function:

◆ TEST() [17/20]

TEST ( multiexp  ,
straus_random   
)

Definition at line 192 of file multiexp.cpp.

193 {
194  std::vector<rct::MultiexpData> data;
195  for (int n = 0; n < 32; ++n)
196  {
197  data.push_back({rct::skGen(), get_p3(rct::scalarmultBase(rct::skGen()))});
198  ASSERT_TRUE(basic(data) == straus(data));
199  }
200 }
rct::key straus(const std::vector< MultiexpData > &data, const std::shared_ptr< straus_cached_data > &cache=NULL, size_t STEP=0)
void skGen(key &sk)
Definition: rctOps.cpp:253
void scalarmultBase(key &aG, const key &a)
Definition: rctOps.cpp:350
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
Here is the call graph for this function:

◆ TEST() [18/20]

TEST ( multiexp  ,
pippenger_random   
)

Definition at line 202 of file multiexp.cpp.

203 {
204  std::vector<rct::MultiexpData> data;
205  for (int n = 0; n < 32; ++n)
206  {
207  data.push_back({rct::skGen(), get_p3(rct::scalarmultBase(rct::skGen()))});
208  ASSERT_TRUE(basic(data) == pippenger(data));
209  }
210 }
rct::key pippenger(const std::vector< MultiexpData > &data, const std::shared_ptr< pippenger_cached_data > &cache=NULL, size_t cache_size=0, size_t c=0)
void skGen(key &sk)
Definition: rctOps.cpp:253
void scalarmultBase(key &aG, const key &a)
Definition: rctOps.cpp:350
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
Here is the call graph for this function:

◆ TEST() [19/20]

TEST ( multiexp  ,
straus_cached   
)

Definition at line 212 of file multiexp.cpp.

213 {
214  static constexpr size_t N = 256;
215  std::vector<rct::MultiexpData> P(N);
216  for (size_t n = 0; n < N; ++n)
217  {
218  P[n].scalar = rct::zero();
219  ASSERT_TRUE(ge_frombytes_vartime(&P[n].point, rct::scalarmultBase(rct::skGen()).bytes) == 0);
220  }
221  std::shared_ptr<rct::straus_cached_data> cache = rct::straus_init_cache(P);
222  for (size_t n = 0; n < N/16; ++n)
223  {
224  std::vector<rct::MultiexpData> data;
225  size_t sz = 1 + crypto::rand<size_t>() % (N-1);
226  for (size_t s = 0; s < sz; ++s)
227  {
228  data.push_back({rct::skGen(), P[s].point});
229  }
230  ASSERT_TRUE(basic(data) == straus(data, cache));
231  }
232 }
std::shared_ptr< straus_cached_data > straus_init_cache(const std::vector< MultiexpData > &data, size_t N=0)
rct::key straus(const std::vector< MultiexpData > &data, const std::shared_ptr< straus_cached_data > &cache=NULL, size_t STEP=0)
void skGen(key &sk)
Definition: rctOps.cpp:253
void scalarmultBase(key &aG, const key &a)
Definition: rctOps.cpp:350
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
int ge_frombytes_vartime(ge_p3 *, const unsigned char *)
key zero()
Definition: rctOps.h:70
Here is the call graph for this function:

◆ TEST() [20/20]

TEST ( multiexp  ,
pippenger_cached   
)

Definition at line 234 of file multiexp.cpp.

235 {
236  static constexpr size_t N = 256;
237  std::vector<rct::MultiexpData> P(N);
238  for (size_t n = 0; n < N; ++n)
239  {
240  P[n].scalar = rct::zero();
241  ASSERT_TRUE(ge_frombytes_vartime(&P[n].point, rct::scalarmultBase(rct::skGen()).bytes) == 0);
242  }
243  std::shared_ptr<rct::pippenger_cached_data> cache = rct::pippenger_init_cache(P);
244  for (size_t n = 0; n < N/16; ++n)
245  {
246  std::vector<rct::MultiexpData> data;
247  size_t sz = 1 + crypto::rand<size_t>() % (N-1);
248  for (size_t s = 0; s < sz; ++s)
249  {
250  data.push_back({rct::skGen(), P[s].point});
251  }
252  ASSERT_TRUE(basic(data) == pippenger(data, cache));
253  }
254 }
rct::key pippenger(const std::vector< MultiexpData > &data, const std::shared_ptr< pippenger_cached_data > &cache=NULL, size_t cache_size=0, size_t c=0)
std::shared_ptr< pippenger_cached_data > pippenger_init_cache(const std::vector< MultiexpData > &data, size_t start_offset=0, size_t N=0)
void skGen(key &sk)
Definition: rctOps.cpp:253
void scalarmultBase(key &aG, const key &a)
Definition: rctOps.cpp:350
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
int ge_frombytes_vartime(ge_p3 *, const unsigned char *)
key zero()
Definition: rctOps.h:70
Here is the call graph for this function: