forked from scipr-lab/libsnark
-
Notifications
You must be signed in to change notification settings - Fork 0
/
variable.hpp
213 lines (148 loc) · 7.21 KB
/
variable.hpp
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
/** @file
*****************************************************************************
Declaration of interfaces for:
- a variable (i.e., x_i),
- a linear term (i.e., a_i * x_i), and
- a linear combination (i.e., sum_i a_i * x_i).
*****************************************************************************
* @author This file is part of libsnark, developed by SCIPR Lab
* and contributors (see AUTHORS).
* @copyright MIT license (see LICENSE file)
*****************************************************************************/
#ifndef VARIABLE_HPP_
#define VARIABLE_HPP_
#include <cstddef>
#include <map>
#include <string>
#include <vector>
namespace libsnark {
/**
* Mnemonic typedefs.
*/
typedef size_t var_index_t;
typedef long integer_coeff_t;
/**
* Forward declaration.
*/
template<typename FieldT>
class linear_term;
/**
* Forward declaration.
*/
template<typename FieldT>
class linear_combination;
/********************************* Variable **********************************/
/**
* A variable represents a formal expression of the form "x_{index}".
*/
template<typename FieldT>
class variable {
public:
var_index_t index;
variable(const var_index_t index = 0) : index(index) {};
linear_term<FieldT> operator*(const integer_coeff_t int_coeff) const;
linear_term<FieldT> operator*(const FieldT &field_coeff) const;
linear_combination<FieldT> operator+(const linear_combination<FieldT> &other) const;
linear_combination<FieldT> operator-(const linear_combination<FieldT> &other) const;
linear_term<FieldT> operator-() const;
bool operator==(const variable<FieldT> &other) const;
};
template<typename FieldT>
linear_term<FieldT> operator*(const integer_coeff_t int_coeff, const variable<FieldT> &var);
template<typename FieldT>
linear_term<FieldT> operator*(const FieldT &field_coeff, const variable<FieldT> &var);
template<typename FieldT>
linear_combination<FieldT> operator+(const integer_coeff_t int_coeff, const variable<FieldT> &var);
template<typename FieldT>
linear_combination<FieldT> operator+(const FieldT &field_coeff, const variable<FieldT> &var);
template<typename FieldT>
linear_combination<FieldT> operator-(const integer_coeff_t int_coeff, const variable<FieldT> &var);
template<typename FieldT>
linear_combination<FieldT> operator-(const FieldT &field_coeff, const variable<FieldT> &var);
/****************************** Linear term **********************************/
/**
* A linear term represents a formal expression of the form "coeff * x_{index}".
*/
template<typename FieldT>
class linear_term {
public:
var_index_t index;
FieldT coeff;
linear_term() {};
linear_term(const variable<FieldT> &var);
linear_term(const variable<FieldT> &var, const integer_coeff_t int_coeff);
linear_term(const variable<FieldT> &var, const FieldT &field_coeff);
linear_term<FieldT> operator*(const integer_coeff_t int_coeff) const;
linear_term<FieldT> operator*(const FieldT &field_coeff) const;
linear_combination<FieldT> operator+(const linear_combination<FieldT> &other) const;
linear_combination<FieldT> operator-(const linear_combination<FieldT> &other) const;
linear_term<FieldT> operator-() const;
bool operator==(const linear_term<FieldT> &other) const;
};
template<typename FieldT>
linear_term<FieldT> operator*(const integer_coeff_t int_coeff, const linear_term<FieldT> <);
template<typename FieldT>
linear_term<FieldT> operator*(const FieldT &field_coeff, const linear_term<FieldT> <);
template<typename FieldT>
linear_combination<FieldT> operator+(const integer_coeff_t int_coeff, const linear_term<FieldT> <);
template<typename FieldT>
linear_combination<FieldT> operator+(const FieldT &field_coeff, const linear_term<FieldT> <);
template<typename FieldT>
linear_combination<FieldT> operator-(const integer_coeff_t int_coeff, const linear_term<FieldT> <);
template<typename FieldT>
linear_combination<FieldT> operator-(const FieldT &field_coeff, const linear_term<FieldT> <);
/***************************** Linear combination ****************************/
template<typename FieldT>
class linear_combination;
template<typename FieldT>
std::ostream& operator<<(std::ostream &out, const linear_combination<FieldT> &lc);
template<typename FieldT>
std::istream& operator>>(std::istream &in, linear_combination<FieldT> &lc);
/**
* A linear combination represents a formal expression of the form "sum_i coeff_i * x_{index_i}".
*/
template<typename FieldT>
class linear_combination {
public:
std::vector<linear_term<FieldT> > terms;
linear_combination() {};
linear_combination(const integer_coeff_t int_coeff);
linear_combination(const FieldT &field_coeff);
linear_combination(const variable<FieldT> &var);
linear_combination(const linear_term<FieldT> <);
linear_combination(const std::vector<linear_term<FieldT> > &all_terms);
/* for supporting range-based for loops over linear_combination */
typename std::vector<linear_term<FieldT> >::const_iterator begin() const;
typename std::vector<linear_term<FieldT> >::const_iterator end() const;
void add_term(const variable<FieldT> &var);
void add_term(const variable<FieldT> &var, const integer_coeff_t int_coeff);
void add_term(const variable<FieldT> &var, const FieldT &field_coeff);
void add_term(const linear_term<FieldT> <);
FieldT evaluate(const std::vector<FieldT> &assignment) const;
linear_combination<FieldT> operator*(const integer_coeff_t int_coeff) const;
linear_combination<FieldT> operator*(const FieldT &field_coeff) const;
linear_combination<FieldT> operator+(const linear_combination<FieldT> &other) const;
linear_combination<FieldT> operator-(const linear_combination<FieldT> &other) const;
linear_combination<FieldT> operator-() const;
bool operator==(const linear_combination<FieldT> &other) const;
bool is_valid(const size_t num_variables) const;
void print(const std::map<size_t, std::string> &variable_annotations = std::map<size_t, std::string>()) const;
void print_with_assignment(const std::vector<FieldT> &full_assignment, const std::map<size_t, std::string> &variable_annotations = std::map<size_t, std::string>()) const;
friend std::ostream& operator<< <FieldT>(std::ostream &out, const linear_combination<FieldT> &lc);
friend std::istream& operator>> <FieldT>(std::istream &in, linear_combination<FieldT> &lc);
};
template<typename FieldT>
linear_combination<FieldT> operator*(const integer_coeff_t int_coeff, const linear_combination<FieldT> &lc);
template<typename FieldT>
linear_combination<FieldT> operator*(const FieldT &field_coeff, const linear_combination<FieldT> &lc);
template<typename FieldT>
linear_combination<FieldT> operator+(const integer_coeff_t int_coeff, const linear_combination<FieldT> &lc);
template<typename FieldT>
linear_combination<FieldT> operator+(const FieldT &field_coeff, const linear_combination<FieldT> &lc);
template<typename FieldT>
linear_combination<FieldT> operator-(const integer_coeff_t int_coeff, const linear_combination<FieldT> &lc);
template<typename FieldT>
linear_combination<FieldT> operator-(const FieldT &field_coeff, const linear_combination<FieldT> &lc);
} // libsnark
#include <libsnark/relations/variable.tcc>
#endif // VARIABLE_HPP_