void main()
{
int i;
float svector[3] = {0.1, -0.345, 7.3};
float *dvector;
float sloadvector[3];
float *dloadvector;
int dim = 3;
int dloaddim=0;
dvector = (float *)malloc(3 * sizeof(float));
dvector[0] = 0.1;
dvector[1] = -0.345;
dvector[2] = 7.3;
save_vector(svector, "sbinary.mat", dim);
save_ascii_vector(svector, "sascii.mat", dim);
save_packed_vector(svector, "spacked.mat", dim);
save_vector(dvector, "dbinary.mat", dim);
save_ascii_vector(dvector, "dascii.mat", dim);
save_packed_vector(dvector, "dpacked.mat", dim);
printf("saved 6 vectors\n");
dloadvector = load_vector("dbinary.mat", &dloaddim);
printf("loaded vector of length %d\n", dloaddim);
for(i=0; i<3; i++)
printf("%4.2f ", dloadvector[i]);
printf ("\n");
load_in_vector(sloadvector, "dascii.mat", dim);
printf("loaded vector of length %d\n", dim);
for(i=0; i<3; i++)
printf("%4.2f ", sloadvector[i]);
printf ("\n");
dloadvector = load_vector("dpacked.mat", &dloaddim);
printf("loaded vector of length %d\n", dloaddim);
for(i=0; i<3; i++)
printf("%4.2f ", dloadvector[i]);
printf ("\n");
load_in_vector(sloadvector, "dbinary.mat", dim);
printf("loaded vector of length %d\n", dim);
for(i=0; i<3; i++)
printf("%4.2f ", sloadvector[i]);
printf ("\n");
dloadvector = load_vector("dascii.mat", &dloaddim);
printf("loaded vector of length %d\n", dloaddim);
for(i=0; i<3; i++)
printf("%4.2f ", dloadvector[i]);
printf ("\n");
load_in_vector(sloadvector, "dpacked.mat", dim);
printf("loaded vector of length %d\n", dim);
for(i=0; i<3; i++)
printf("%4.2f ", sloadvector[i]);
printf ("\ndone.\n");
}
void load(std::vector<X>& x, std::istream& in)
{
typename std::vector<X>::size_type size;
load(size, in);
x.resize(size);
load_vector(x, in);
}
void load(Archive& ar, const unsigned Integer) {
load_sparse_matrix(ar, reduce_A_);
load_vector(ar, W_);
ar & R_;
ar & G_;
ar & C_;
ar & ins_;
ar & iter_;
ar & time_;
}
//Refer to apps_sfdl_gen/cql_rw_si_cons.h for constants to use when generating input.
// this name stands for cql read/write select insert.
void cql_rw_siVerifierInpGenHw::create_input(mpq_t* input_q, int num_inputs)
{
srand(time(NULL));
mpq_t* full_db_handle;
int num_ints = sizeof(Student_handle_t) / sizeof(uint64_t);
alloc_init_vec(&full_db_handle, num_ints);
Student_handle_t handle;
if (generate_states) {
// SIZE should be a power of 2.
int number_of_rows = SIZE - 1;
// get the full handle of a DB.
handle = create_db(number_of_rows, ("prover_1_" + shared_bstore_file_name).c_str());
uint64_t* input_ptr = (uint64_t*)&handle;
for(int i = 0; i < num_ints; i++) {
mpq_set_ui(full_db_handle[i], input_ptr[i], 1);
}
dump_vector(num_ints, full_db_handle, "db_handle", FOLDER_PERSIST_STATE);
} else {
// import the root hash from a place.
load_vector(num_ints, full_db_handle, "db_handle", FOLDER_PERSIST_STATE);
uint64_t* input_ptr = (uint64_t*)&handle;
for(int i = 0; i < num_ints; i++) {
input_ptr[i] = mpz_get_ui(mpq_numref(full_db_handle[i]));
}
}
struct In input;
Student_handle_t empty_handle;
memset(&input, 0, sizeof(input));
// get a succinct handle of a DB using hashput.
char db_file_path[BUFLEN];
snprintf(db_file_path, BUFLEN - 1, "%s/block_stores/prover_1_%s", FOLDER_STATE, shared_bstore_file_name.c_str());
HashBlockStore* bs = new ConfigurableBlockStore(db_file_path);
hashput2(bs, &(input.db_handle), &handle);
delete bs;
// assign it to input_q
uint64_t* input_ptr = (uint64_t*)&input.db_handle;
int number_of_hash_elements = sizeof(hash_t) / sizeof(uint64_t);
for(int i = 0; i < number_of_hash_elements; i++) {
mpq_set_ui(input_q[i], input_ptr[i], 1);
}
for (int i = number_of_hash_elements; i < num_inputs; i++) {
mpq_set_ui(input_q[i], rand(), 1);
}
clear_del_vec(full_db_handle, num_ints);
}
void PolyEvalD3Prover::deduce_queries() {
int f_con_filled = -1;
load_vector(num_coefficients, coefficients, (char *)"coefficients");
for (int rho=0; rho<num_repetitions; rho++) {
if (rho == 0) m_plainq.begin_with_init();
else m_plainq.begin_with_history();
int query_id = 1;
for (int i=0; i<NUM_REPS_LIN; i++) {
v->create_lin_test_queries(size_f1_vec, f1_q1, f1_q2, f1_q3, NULL,
f_con_filled, NULL, prime);
f_con_filled += 3;
v->create_lin_test_queries(size_f2_vec, f2_q1, f2_q2, f2_q3, NULL,
f_con_filled, NULL, prime);
f_con_filled += 3;
v->create_lin_test_queries(size_f3_vec, f3_q1, f3_q2, f3_q3, NULL,
f_con_filled, NULL, prime);
f_con_filled += 3;
//TODO: can be folded into a function
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f1_vec, f1_q1, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f1_vec, f1_q2, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f1_vec, f1_q3, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f2_vec, f2_q1, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f2_vec, f2_q2, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f2_vec, f2_q3, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f3_vec, f3_q1, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f3_vec, f3_q2, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f3_vec, f3_q3, scratch_str);
//send_file(scratch_str);
// use one of the linearity queries as self correction queries
if (i == 0) {
for (int i=0; i<size_f1_vec; i++) {
mpz_set(f1_q4[i], f1_q1[i]);
mpz_set(f1_q5[i], f1_q2[i]);
}
for (int i=0; i<size_f2_vec; i++)
mpz_set(f2_q4[i], f2_q1[i]);
for (int i=0; i<size_f3_vec; i++)
mpz_set(f3_q4[i], f3_q1[i]);
}
}
v->create_corr_test_queries_reuse(size_f1_vec, f1_q4, size_f1_vec, f1_q5,
f2_q1, f2_q4, NULL, NULL, NULL,
f_con_filled, NULL, f_con_filled, NULL,
f_con_filled, NULL, prime, false);
f_con_filled += 1;
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f2_vec, f2_q1, scratch_str);
//send_file(scratch_str);
v->create_corr_test_queries_reuse(size_f1_vec, f1_q4,
size_f2_vec, f2_q4, f3_q1, f3_q4,
NULL, NULL, NULL, f_con_filled,
NULL, f_con_filled, NULL, f_con_filled,
NULL, prime, false);
f_con_filled += 1;
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f3_vec, f3_q1, scratch_str);
//send_file(scratch_str);
// circuit test
v->get_random_vec_pub(size_f1_vec+1, alpha, prime);
// formulate a; a = -\alpha_0 \cdot degree-2 coefficients
mpz_neg(neg, alpha[0]);
// set the query to zero first
for (int i=0; i<size_f3_vec; i++) {
mpz_set_ui(f3_q1[i], 0);
}
int index_coefficients = 0;
int index_query = 0;
for (int i=0; i<size_f1_vec; i++) {
for (int j=0; j<=i; j++) {
for (int k=0; k<=j; k++) {
index_query = (i*size_f1_vec+j)*size_f1_vec+k;
mpz_mul(f3_q1[index_query], neg, coefficients[index_coefficients]);
mpz_mod(f3_q1[index_query], f3_q1[index_query], prime);
index_coefficients++;
}
}
}
int offset = (size_f3_vec + 3*size_f2_vec + 2*size_f1_vec)/6;
// quadratic part of circuit test query
for (int i=0; i<size_f2_vec; i++) {
mpz_set_ui(f2_q1[i], 0);
}
int index;
int k = 0;
for (int i=0; i<size_f1_vec; i++) {
for (int j=0; j<=i; j++) {
index = size_f1_vec*i + j;
mpz_mul(f2_q1[index], neg, coefficients[offset+k]);
mpz_mod(f2_q1[index], f2_q1[index], prime);
k++;
}
}
offset += (size_f1_vec * size_f1_vec + size_f1_vec)/2;
// formulate b; b = -\alpha_0 \cdot degree-1 coefficients + [\alpha_1,
// \alpha_2, ... , \alpha_{size_f1_vec+1}]
for (int i=0; i<size_f1_vec; i++) {
mpz_mul(f1_q2[i], neg, coefficients[offset+i]);
mpz_add(f1_q2[i], alpha[i+1], f1_q2[i]);
mpz_mod(f1_q2[i], f1_q2[i], prime);
}
v->create_ckt_test_queries(size_f1_vec, f1_q2, f1_q3, f1_q4,
NULL, f_con_filled, NULL, prime);
f_con_filled += 1;
v->create_ckt_test_queries(size_f2_vec, f2_q1, f2_q3,
f2_q4, NULL, f_con_filled, NULL, prime);
f_con_filled += 1;
v->create_ckt_test_queries(size_f3_vec, f3_q1,
f3_q3, f3_q4, NULL, f_con_filled, NULL, prime);
f_con_filled += 1;
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f1_vec, f1_q3, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f2_vec, f2_q3, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f3_vec, f3_q3, scratch_str);
//send_file(scratch_str);
m_plainq.end();
}
}
//PROVER's CODE
void PolyEvalD3Prover::
prover_computation_commitment() {
load_vector(expansion_factor*m, f1_commitment, (char *)"f1_commitment_query", FOLDER_WWW_DOWNLOAD);
load_vector(expansion_factor*size_f2_vec, f2_commitment, (char *)"f2_commitment_query", FOLDER_WWW_DOWNLOAD);
load_vector(expansion_factor*size_f3_vec, f3_commitment, (char *)"f3_commitment_query", FOLDER_WWW_DOWNLOAD);
m_computation.begin_with_init();
//for (int k=0; k<INNER_LOOP_SMALL; k++)
load_vector(num_coefficients, coefficients, (char *)"coefficients", FOLDER_WWW_DOWNLOAD);
m_computation.end();
for (int i=batch_start; i<=batch_end; i++) {
m_computation.begin_with_history();
//for (int k=0; k<INNER_LOOP_SMALL; k++)
{
snprintf(scratch_str, BUFLEN-1, "input_b_%d", i);
load_vector(m, variables, scratch_str, FOLDER_WWW_DOWNLOAD);
for (int j=0; j<expansion_factor; j++)
mpz_set_ui(output[j], 0);
computation_polyeval(output[0]);
// start saving the state
snprintf(scratch_str, BUFLEN-1, "output_b_%d", i);
dump_scalar(output[0], scratch_str, FOLDER_WWW_DOWNLOAD);
}
m_computation.end();
computation_assignment(output[0]);
snprintf(scratch_str, BUFLEN-1, "f1_assignment_vector_b_%d", i);
dump_vector(m, F1, scratch_str, FOLDER_WWW_DOWNLOAD);
snprintf(scratch_str, BUFLEN-1, "f2_assignment_vector_b_%d", i);
dump_vector(size_f2_vec, F2, scratch_str, FOLDER_WWW_DOWNLOAD);
snprintf(scratch_str, BUFLEN-1, "f3_assignment_vector_b_%d", i);
dump_vector(size_f3_vec, F3, scratch_str, FOLDER_WWW_DOWNLOAD);
}
for (int i=batch_start; i<=batch_end; i++) {
if (i == 0)
m_answer_queries.begin_with_init();
else
m_answer_queries.begin_with_history();
snprintf(scratch_str, BUFLEN-1, "f1_assignment_vector_b_%d", i);
load_vector(m, F1, scratch_str, FOLDER_WWW_DOWNLOAD);
snprintf(scratch_str, BUFLEN-1, "f2_assignment_vector_b_%d", i);
load_vector(size_f2_vec, F2, scratch_str, FOLDER_WWW_DOWNLOAD);
snprintf(scratch_str, BUFLEN-1, "f3_assignment_vector_b_%d", i);
load_vector(size_f3_vec, F3, scratch_str, FOLDER_WWW_DOWNLOAD);
v->dot_product_enc(m, f1_commitment, F1, dotp[0], dotp[1]);
v->dot_product_enc(size_f2_vec, f2_commitment, F2, output[0], output[1]);
v->add_enc(dotp[0], dotp[1], dotp[0], dotp[1], output[0], output[1]);
v->dot_product_enc(size_f3_vec, f3_commitment, F3, output[0], output[1]);
v->add_enc(dotp[0], dotp[1], dotp[0], dotp[1], output[0], output[1]);
snprintf(scratch_str, BUFLEN-1, "f_commitment_answer_b_%d", i);
dump_vector(expansion_factor, dotp, scratch_str, FOLDER_WWW_DOWNLOAD);
m_answer_queries.end();
}
}
void ColorVisionDeficiency::apply(Color *input, Color *output)
{
Color linear_input, linear_output;
color_rgb_get_linear(input, &linear_input);
vector3 vi, vo1, vo2;
load_vector(&linear_input, &vi);
matrix3x3 matrix1, matrix2;
int index = floor(strength * 10);
int index_secondary = std::min(index + 1, 10);
float interpolation_factor = 1 - ((strength * 10) - index);
vector3 lms;
if ((type == PROTANOPIA) || (type == DEUTERANOPIA) || (type == TRITANOPIA)){
load_matrix(rgb_to_lms, &matrix1);
load_matrix(lms_to_rgb, &matrix2);
vector3_multiply_matrix3x3(&vi, &matrix1, &lms);
}
switch (type){
case PROTANOMALY:
load_matrix(protanomaly[index], &matrix1);
load_matrix(protanomaly[index_secondary], &matrix2);
vector3_multiply_matrix3x3(&vi, &matrix1, &vo1);
vector3_multiply_matrix3x3(&vi, &matrix2, &vo2);
break;
case DEUTERANOMALY:
load_matrix(deuteranomaly[index], &matrix1);
load_matrix(deuteranomaly[index_secondary], &matrix2);
vector3_multiply_matrix3x3(&vi, &matrix1, &vo1);
vector3_multiply_matrix3x3(&vi, &matrix2, &vo2);
break;
case TRITANOMALY:
load_matrix(tritanomaly[index], &matrix1);
load_matrix(tritanomaly[index_secondary], &matrix2);
vector3_multiply_matrix3x3(&vi, &matrix1, &vo1);
vector3_multiply_matrix3x3(&vi, &matrix2, &vo2);
break;
case PROTANOPIA:
if (lms.z / lms.y < rgb_anchor[2] / rgb_anchor[1]){
lms.x = -(protanopia_abc[0].y * lms.y + protanopia_abc[0].z * lms.z) / protanopia_abc[0].x;
}else{
lms.x = -(protanopia_abc[1].y * lms.y + protanopia_abc[1].z * lms.z) / protanopia_abc[1].x;
}
vector3_multiply_matrix3x3(&lms, &matrix2, &vo1);
load_vector(&linear_input, &vo2);
interpolation_factor = strength;
break;
case DEUTERANOPIA:
if (lms.z / lms.x < rgb_anchor[2] / rgb_anchor[0]){
lms.y = -(deuteranopia_abc[0].x * lms.x + deuteranopia_abc[0].z * lms.z) / deuteranopia_abc[0].y;
}else{
lms.y = -(deuteranopia_abc[1].x * lms.x + deuteranopia_abc[1].z * lms.z) / deuteranopia_abc[1].y;
}
vector3_multiply_matrix3x3(&lms, &matrix2, &vo1);
load_vector(&linear_input, &vo2);
interpolation_factor = strength;
break;
case TRITANOPIA:
if (lms.y / lms.x < rgb_anchor[1] / rgb_anchor[0]){
lms.z = -(tritanopia_abc[0].x * lms.x + tritanopia_abc[0].y * lms.y) / tritanopia_abc[0].z;
}else{
lms.z = -(tritanopia_abc[1].x * lms.x + tritanopia_abc[1].y * lms.y) / tritanopia_abc[1].z;
}
vector3_multiply_matrix3x3(&lms, &matrix2, &vo1);
load_vector(&linear_input, &vo2);
interpolation_factor = strength;
break;
default:
color_copy(input, output);
return;
}
linear_output.rgb.red = vo1.x * interpolation_factor + vo2.x * (1 - interpolation_factor);
linear_output.rgb.green = vo1.y * interpolation_factor + vo2.y * (1 - interpolation_factor);
linear_output.rgb.blue = vo1.z * interpolation_factor + vo2.z * (1 - interpolation_factor);
color_linear_get_rgb(&linear_output, output);
color_rgb_normalize(output);
}
void MatrixCubicVerifier::create_plain_queries() {
uint32_t m2 = input_size*input_size;
// keeps track of #filled coins
int f1_con_filled = -1;
for (int rho=0; rho<num_repetitions; rho++) {
if (rho == 0) m_plainq.begin_with_init();
else m_plainq.begin_with_history();
int query_id = 1;
for (int i=0; i<NUM_REPS_LIN; i++) {
v->create_lin_test_queries(hadamard_code_size, f1_q1, f1_q2, f1_q3, f1_consistency, f1_con_filled, f_con_coins, prime);
f1_con_filled += 3;
//snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
//dump_vector(hadamard_code_size, f1_q1, scratch_str);
//send_file(scratch_str);
//snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
//dump_vector(hadamard_code_size, f1_q2, scratch_str);
//send_file(scratch_str);
query_id++;
//snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
//dump_vector(hadamard_code_size, f1_q3, scratch_str);
//send_file(scratch_str);
// use one of the linearity queries as self correction queries
if (i == 0) {
for (int i=0; i<hadamard_code_size; i++)
mpz_set(f1_q4[i], f1_q1[i]);
}
}
// f1_q1 = q3
// f1_q2 = q4
// f2_q1 = q1
// f2_q2 = q2
mpz_set_ui(f_con_coins[f1_con_filled+1], 0);
mpz_set_ui(f_con_coins[f1_con_filled+2], 0);
f1_con_filled += 2;
query_id += 2;
v->create_corr_test_queries_vproduct(input_size, f2_q1, f2_q2, f1_q1, f1_q4,
f1_consistency, f1_con_filled, f_con_coins, prime);
f1_con_filled += 1;
//snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
//dump_vector(hadamard_code_size, f1_q1, scratch_str);
//send_file(scratch_str);
m_plainq.end();
// compute answers to f1(q1) and f1(q2) locally now itself
if (rho == 0) m_runtests.begin_with_init();
else m_runtests.begin_with_history();
for (int b=0; b<batch_size; b++) {
mpz_set_ui(a1, 0);
mpz_set_ui(a2, 0);
snprintf(scratch_str, BUFLEN-1, "input1_b_%d", b);
load_vector(2*input_size*input_size, A, scratch_str);
//snprintf(scratch_str, BUFLEN-1, "input1_b_%d", b);
//load_vector(input_size*input_size, B, scratch_str);
int index;
mpz_set_ui(a3, 0);
for (int k=0; k<input_size; k++) {
// dot product of k^th row of A with k^th row of f2_q1
//\sum_{j=1}{m}{A[k][j] \cdot f2_q1[k][j]}
mpz_set_ui(a1, 0);
mpz_set_ui(a2, 0);
for (int j=0; j<input_size; j++) {
index = j*input_size+k;
mpz_mul(temp, A[index], f2_q1[index]);
mpz_add(a1, a1, temp);
}
for (int i=0; i<input_size; i++) {
index = k*input_size+i;
mpz_mul(temp, B[index], f2_q2[index]);
mpz_add(a2, a2, temp);
}
mpz_mul(temp, a1, a2);
mpz_add(a3, a3, temp);
mpz_mod(a3, a3, prime);
}
snprintf(scratch_str, BUFLEN-1, "corr_answer_b_%d_r_%d", b, rho);
dump_scalar(a3, scratch_str);
}
m_runtests.end();
// circuit test
m_plainq.begin_with_history();
v->get_random_vec_pub(input_size*input_size, gamma, prime);
for (int i=0; i<hadamard_code_size; i++)
mpz_set_ui(f1_q1[i], 0);
int index, index2;
for (int i=0; i<input_size; i++) {
for (int j=0; j<input_size; j++) {
// add gamma[i*input_size+j] to all the cells in query
index2 = i*input_size+j;
for (int k=0; k<input_size; k++) {
index = index2 * input_size+k;
mpz_add(f1_q1[index], f1_q1[index], gamma[index2]);
}
}
}
for (int i=0; i<input_size*input_size*input_size; i++)
mpz_mod(f1_q1[i], f1_q1[i], prime);
v->create_ckt_test_queries(hadamard_code_size, f1_q1, f1_q3, f1_q4, f1_consistency,
f1_con_filled, f_con_coins, prime);
//snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
//dump_vector(hadamard_code_size, f1_q3, scratch_str);
//send_file(scratch_str);
f1_con_filled += 1;
m_plainq.end();
m_runtests.begin_with_history();
// finally compute c
for (int i=0; i<batch_size; i++) {
snprintf(scratch_str, BUFLEN-1, "output_b_%d", i);
load_vector(input_size*input_size, C, scratch_str);
int c_index = i * num_repetitions + rho;
mpz_set_ui(c_values[c_index], 0);
for (int j=0; j<input_size*input_size; j++) {
mpz_neg(temp, gamma[j]);
mpz_mul(temp, temp, C[j]);
mpz_add(c_values[c_index], c_values[c_index], temp);
}
}
m_runtests.end();
}
dump_vector(hadamard_code_size, f1_consistency, (char *)"f1_consistency_query");
send_file((char *)"f1_consistency_query");
}
void Verifier::prepare_answers(int beta) {
#if NONINTERACTIVE == 1
prepare_noninteractive_answers(beta);
#else
#if VERBOSE == 1
cout << endl << "LOG: Batch " << beta << endl;
#endif
FILE *fp = NULL;
if (optimize_answers) {
char f_name[BUFLEN];
snprintf(f_name, BUFLEN - 1, "answers_%d", beta + 1);
snprintf(f_name, BUFLEN - 1, "%s/answers_%d",
FOLDER_STATE, beta + 1);
fp = fopen(f_name, "rb");
if (fp == NULL) {
printf("Failed to open %s file for reading.", f_name);
exit(1);
}
}
// only one commitment answer and one consistency answer
string commitment_answer_str = "f_commitment_answer_b_%d";
snprintf(scratch_str, BUFLEN - 1, commitment_answer_str.c_str(), beta);
load_vector(expansion_factor, temp_arr_ptrs[0], scratch_str);
if (!optimize_answers) {
string consistency_answer_str = "f_consistency_answer_b_%d";
snprintf(scratch_str, BUFLEN - 1, consistency_answer_str.c_str(), beta);
load_scalar(a, scratch_str);
} else {
size_t bytes = mpz_inp_raw(a, fp);
fseek(fp, bytes, SEEK_CUR);
}
for (uint32_t j=0; j<num_repetitions*num_lin_pcp_queries; j++)
mpz_set_ui(f_answers[j], 0);
std::list<string> files = get_files_in_dir((char *)FOLDER_STATE);
for (int rho = 0; rho < num_repetitions; rho++) {
if (!optimize_answers) {
char *file_exp = (char *)"_qquery_answer_b_%d_r_%d";
snprintf(scratch_str, BUFLEN-1, file_exp, beta, rho);
std::list<string>::const_iterator it = files.begin();
for (; it != files.end(); it++) {
string file_name = *it;
size_t b_index = file_name.find(scratch_str);
if (b_index != string::npos) {
int q_num = atoi(file_name.substr(file_name.find("q") + 1, b_index).c_str());
load_scalar(f_answers[rho * num_lin_pcp_queries + Q_list[q_num - 1]],
(char*)file_name.c_str());
}
}
} else {
for (uint32_t q = 0; q < Q_list.size(); q++) {
size_t bytes =
mpz_inp_raw(f_answers[rho * num_lin_pcp_queries + Q_list[q]], fp);
fseek(fp, bytes, SEEK_CUR);
}
}
//populate_answers(f_answers, rho, num_repetitions, beta);
}
snprintf(scratch_str, BUFLEN-1, "input_b_%d", beta);
load_vector(size_input, input, scratch_str);
snprintf(scratch_str, BUFLEN-1, "output_b_%d", beta);
load_vector(size_output, output, scratch_str);
if (output_q != NULL) {
snprintf(scratch_str, BUFLEN-1, "output_q_b_%d", beta);
load_vector(size_output, output_q, scratch_str);
if (verify_conversion_to_z(size_output, output, output_q, prime) == false) {
cout<<"LOG: Prover presented two different versions of output"<<endl;
exit(1);
}
}
if (fp != NULL)
fclose(fp);
#endif
}
void load_obj(unsigned int shader, char* fname) {
FILE *ifp;
ifp = fopen(fname, "r");
int i;
char lineType[2];
while ( fscanf(ifp, "%s", lineType) != EOF ) {
if ( lineType[0] == '#' ) {
// Line is comment
}
else if ( lineType[0] == 'm' ) {
// Line is material
}
else if ( lineType[0] == 'v' ) {
// Normals
if ( lineType[1] == 'n' ) {
load_vector(ifp, normalArray, &numNormals);
numNormals++;
}
// Texcoord
else if ( lineType[1] == 't' ) {
load_coord(ifp, texCoordArray, &numTexCoords);
numTexCoords++;
}
// Tangent
else if ( lineType[1] == 'x' ) {
load_vector(ifp, tangentArray, &numTangents);
// numTangents++;
}
// Bitangent
else if ( lineType[1] == 'y' ) {
load_vector(ifp, biTangentArray, &numTangents);
numTangents++;
}
// Vertex
else {
load_vector(ifp, vertexArray, &numVertices);
numVertices++;
}
} else if ( lineType[0] == 'f' ) {
load_vector_face(ifp, faceArray, &numFaces);
numFaces++;
}
char line[100];
fgets (line, 100, ifp);
}
fclose(ifp);
GLint index_tangent = glGetAttribLocation(shader, "tangent");
GLint index_bitangent = glGetAttribLocation(shader, "bitangent");
for( i=0; i<numFaces; i++ ) {
int j = 0;
for (j=0; j<4; j++) {
// Vertices
indices[i*12 + j*3 + 0] = vertexArray[faceArray[i].v[j]-1].x;
indices[i*12 + j*3 + 1] = vertexArray[faceArray[i].v[j]-1].y;
indices[i*12 + j*3 + 2] = vertexArray[faceArray[i].v[j]-1].z;
// Texcoords
indices[numFaces*12 + i*8 + j*2 + 0] = texCoordArray[faceArray[i].t[j]-1].x;
indices[numFaces*12 + i*8 + j*2 + 1] = texCoordArray[faceArray[i].t[j]-1].y;
// Normals
indices[numFaces*20 + i*12 + j*3 + 0] = normalArray[faceArray[i].n[j]-1].x;
indices[numFaces*20 + i*12 + j*3 + 1] = normalArray[faceArray[i].n[j]-1].y;
indices[numFaces*20 + i*12 + j*3 + 2] = normalArray[faceArray[i].n[j]-1].z;
// Shader stuff
int vi = faceArray[i].v[j]-1;
int ti = faceArray[i].t[j]-1;
int ni = faceArray[i].n[j]-1;
glNormal3fv( toArray(normalArray[ni]));
glTexCoord2fv( toArrayCoords(texCoordArray[ti]));
glVertexAttrib3fv(index_tangent, toArray(tangentArray[vi]));
glVertexAttrib3fv(index_bitangent, toArray(biTangentArray[vi]));
glVertex3fv( toArray(vertexArray[vi]));
}
}
}
