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
/** @file
*****************************************************************************
Implementation of misc math and serialization utility functions
*****************************************************************************
* @author This file is part of libff, developed by SCIPR Lab
* and contributors (see AUTHORS).
* @copyright MIT license (see LICENSE file)
*****************************************************************************/
#include <algorithm>
#include <cassert>
#include <cstdarg>
#include <cstdint>
#include <../trusted_libff/libff/common/utils.hpp>
namespace libff {
size_t get_power_of_two(size_t n)
{
n--;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n++;
return n;
}
size_t log2(size_t n)
/* returns ceil(log2(n)), so 1ul<<log2(n) is the smallest power of 2,
that is not less than n. */
{
size_t r = ((n & (n-1)) == 0 ? 0 : 1); // add 1 if n is not power of 2
while (n > 1)
{
n >>= 1;
r++;
}
return r;
}
size_t to_twos_complement(int i, size_t w)
{
assert(i >= -(1l<<(w-1)));
assert(i < (1l<<(w-1)));
return (i >= 0) ? i : i + (1l<<w);
}
int from_twos_complement(size_t i, size_t w)
{
assert(i < (1ul<<w));
return (i < (1ul<<(w-1))) ? i : i - (1ul<<w);
}
size_t bitreverse(size_t n, const size_t l)
{
size_t r = 0;
for (size_t k = 0; k < l; ++k)
{
r = (r << 1) | (n & 1);
n >>= 1;
}
return r;
}
bit_vector int_list_to_bits(const std::initializer_list<unsigned long> &l, const size_t wordsize)
{
bit_vector res(wordsize*l.size());
for (size_t i = 0; i < l.size(); ++i)
{
for (size_t j = 0; j < wordsize; ++j)
{
res[i*wordsize + j] = (*(l.begin()+i) & (1ul<<(wordsize-1-j)));
}
}
return res;
}
long long div_ceil(long long x, long long y)
{
return (x + (y-1)) / y;
}
bool is_little_endian()
{
uint64_t a = 0x12345678;
unsigned char *c = (unsigned char*)(&a);
return (*c = 0x78);
}
std::string FORMAT(const std::string &prefix, const char* format, ...)
{
const static size_t MAX_FMT = 256;
char buf[MAX_FMT];
va_list args;
va_start(args, format);
vsnprintf(buf, MAX_FMT, format, args);
va_end(args);
return prefix + std::string(buf);
}
void serialize_bit_vector(skale::ostream &out, const bit_vector &v)
{
out << v.size() << "\n";
for (size_t i = 0; i < v.size(); ++i)
{
out << v[i] << "\n";
}
}
void deserialize_bit_vector(skale::istream &in, bit_vector &v)
{
size_t size;
in >> size;
v.resize(size);
for (size_t i = 0; i < size; ++i)
{
bool b;
in >> b;
v[i] = b;
}
}
} // libff