int test_matrix_add_element(void) {
Matrix *matrix = new_matrix();
if(matrix == NULL) {
LOG_ERR("add element to matrix -> new matrix");
return 1;
}
Element *element = element_new(0,0,100);
if(element == NULL) {
safe_free(matrix);
LOG_ERR("add element to matrix -> new element");
return 1;
}
Status status = matrix_add(matrix, element);
if(status != STAT_SUCCESS) {
safe_free(matrix);
safe_free(element);
LOG_ERR("add element to matrix");
return 1;
}
safe_free(element);
safe_free(matrix);
LOG_SUCCESS("add element to matrix");
return 0;
}
int test_matrix_update(void) {
Matrix *matrix = new_matrix();
int res = fill_matrix(matrix, 20, 20);
if(res != 0) {
LOG_ERR("test matrix update -> fill matrix error");
return res;
}
Element *new_element = element_new(10, 10, 10+10);
Status status = matrix_update(matrix, new_element);
if(status != STAT_SUCCESS) {
LOG_ERR("test matrix update");
return 1;
} else {
Element *element = matrix_find_by_pos(matrix, 10, 10);
if(element == NULL) {
LOG_ERR("test matrix update -> find element error");
return 1;
} else {
if(new_element->value == element->value) {
LOG_SUCCESS("test matrix update");
return 0;
} else {
LOG_ERR("test matrix update, can't update");
return 1;
}
}
}
}
static val_ptr v_field_cast(val_ptr v, tree_ptr t) {
// TODO: Check args, x is an element.
val_ptr x = tree_eval((tree_ptr)darray_at(t->child, 0));
element_ptr e = x->elem;
if (e->field == M) {
if (v->field == M) return x;
element_ptr e2 = element_new(v->field);
if (element_is0(e)) // if 'set0' is not 'set1' in base field of GT, but we hope 'GT(0)' calls 'set1', we may directly call 'element_set0' here
element_set0(e2);
else if (element_is1(e)) // reason is same as above
element_set1(e2);
else
element_set_multiz(e2, (multiz)e->data);
x->elem = e2;
return x;
}
if (v->field == M) {
// Map to/from integer. TODO: Map to/from multiz instead.
mpz_t z;
mpz_init(z);
element_to_mpz(z, e);
element_clear(e);
element_init(e, v->field);
element_set_mpz(e, z);
mpz_clear(z);
}
return x;
}
static val_ptr run_extend(val_ptr v[]) {
// TODO: Check v[1] is multiz poly.
field_ptr fx = (field_ptr)pbc_malloc(sizeof(*fx));
field_init_poly(fx, v[0]->field);
element_ptr poly = element_new(fx);
element_set_multiz(poly, (multiz)(v[1]->elem->data));
field_ptr f = (field_ptr)pbc_malloc(sizeof(*f));
field_init_polymod(f, poly);
element_free(poly);
return val_new_field(f);
}
int test_new_element(void) {
Element *element = element_new(0,0,100);
if(element == NULL) {
LOG_ERR("new element");
return 1;
}
safe_free(element);
LOG_SUCCESS("new element");
return 0;
}
static int fill_matrix(Matrix *matrix, unsigned row, unsigned col) {
for(unsigned i =0; i <= row; i++) {
for(unsigned j = 0; j <= col; j++) {
Element *element = element_new(i, j, i*j);
if(element == NULL)
return 1;
Status status = matrix_add(matrix, element);
if(status != STAT_SUCCESS)
return 1;
}
}
return 0;
}
list_part_t *insert_new_partition(list_part_t *list_part, partition_t *part, const int force_insert, int *insert_error)
{
list_part_t *prev=NULL;
list_part_t *next;
*insert_error=0;
for(next=list_part;;next=next->next)
{ /* prev new next */
if((next==NULL)||
(part->part_offset<next->part->part_offset) ||
(part->part_offset==next->part->part_offset &&
((part->part_size<next->part->part_size) ||
(part->part_size==next->part->part_size && (force_insert==0 || part->sb_offset < next->part->sb_offset)))))
{
if(force_insert==0 &&
(next!=NULL) &&
(next->part->part_offset==part->part_offset) &&
(next->part->part_size==part->part_size) &&
(next->part->part_type_i386==part->part_type_i386) &&
(next->part->part_type_mac==part->part_type_mac) &&
(next->part->part_type_sun==part->part_type_sun) &&
(next->part->part_type_xbox==part->part_type_xbox) &&
(next->part->upart_type==part->upart_type || part->upart_type==UP_UNK))
{ /*CGR 2004/05/31*/
if(next->part->status==STATUS_DELETED)
{
next->part->status=part->status;
}
*insert_error=1;
return list_part;
}
{ /* prev new_element next */
list_part_t *new_element;
new_element=element_new(part);
new_element->next=next;
new_element->prev=prev;
if(next!=NULL)
next->prev=new_element;
if(prev!=NULL)
{
prev->next=new_element;
return list_part;
}
return new_element;
}
}
prev=next;
}
}
static val_ptr v_field_cast(val_ptr v, tree_ptr t) {
// TODO: Check args, x is an element.
val_ptr x = tree_eval(darray_at(t->child, 0));
element_ptr e = x->elem;
if (e->field == M) {
if (v->field == M) return x;
element_ptr e2 = element_new(v->field);
element_set_multiz(e2, e->data);
x->elem = e2;
return x;
}
if (v->field == M) {
// Map to/from integer. TODO: Map to/from multiz instead.
mpz_t z;
mpz_init(z);
element_to_mpz(z, e);
element_clear(e);
element_init(e, v->field);
element_set_mpz(e, z);
mpz_clear(z);
}
return x;
}
int test_element( int argc, char *argv[] )
{
Element *e = element_new();
g_return_val_if_fail( e->adjacent_halfedge == NULL , 1 );
element_free( e );
Point2 p1, p2, p3;
point2_set( &p1, 0.0, 1.0 );
point2_set( &p2, 0.0, 0.0 );
point2_set( &p3, sqrt( 3.0 ), 0.0 );
gdouble a1, a2, a3;
triangle_angles( &p1, &p2, &p3, &a1, &a2, &a3 );
g_return_val_if_fail( fabs( a1 - G_PI/3.0) < SMALL_NUMBER, 1 );
g_return_val_if_fail( fabs( a2 - G_PI/2.0) < SMALL_NUMBER, 1 );
g_return_val_if_fail( fabs( a3 - G_PI/6.0) < SMALL_NUMBER, 1 );
a1 = triangle_circumcircle_radius( &p1, &p2, &p3 );
g_return_val_if_fail( fabs( a1 - 1.0 ) < SMALL_NUMBER, 1 );
a1 = triangle_circumcircle_radius_edge_length( 1.0, sqrt( 3.0 ), 2.0 );
g_return_val_if_fail( fabs( a1 - 1.0 ) < SMALL_NUMBER, 1 );
Point2 p;
triangle_circumcenter_coordinates( &p1, &p2, &p3, &p );
g_return_val_if_fail( fabs( p.x - sqrt( 3.0 )/2.0 ) < SMALL_NUMBER, 1 );
g_return_val_if_fail( fabs( p.y - 1.0/2.0 ) < SMALL_NUMBER, 1 );
a1 = triangle_area( &p1, &p2, &p3 );
g_return_val_if_fail( fabs( a1 - sqrt( 3.0 )/2.0 ) < SMALL_NUMBER, 1 );
Mesh *mesh = mesh_new();
Node *n1 = mesh_add_node( mesh, 0.0, 1.0 );
Node *n2 = mesh_add_node( mesh, 0.0, 0.0 );
Node *n3 = mesh_add_node( mesh, sqrt(3.0), 0.0 );
Edge *e1 = mesh_add_edge( mesh, n1, n2 );
Edge *e2 = mesh_add_edge( mesh, n2, n3 );
Edge *e3 = mesh_add_edge( mesh, n3, n1 );
Element *el = mesh_add_element( mesh, &e1->he[0], &e2->he[0], &e3->he[0] );
gdouble l1, l2, l3;
element_edge_lengths( el, &l1, &l2, &l3 );
g_return_val_if_fail( fabs( l1 - 1.0) < SMALL_NUMBER, 1);
g_return_val_if_fail( fabs( l2 - sqrt(3.0)) < SMALL_NUMBER, 1);
g_return_val_if_fail( fabs( l3 - 2.0) < SMALL_NUMBER, 1);
HalfEdge *he = element_min_edge( el, &l1 );
g_return_val_if_fail( he->edge == e1, 1 );
g_return_val_if_fail( fabs( l1 - 1.0) < SMALL_NUMBER, 1);
l1 = element_min_edge_length( el );
g_return_val_if_fail( fabs( l1 - 1.0) < SMALL_NUMBER, 1);
he = element_max_edge( el, &l1 );
g_return_val_if_fail( he->edge == e3, 1 );
g_return_val_if_fail( fabs( l1 - 2.0) < SMALL_NUMBER, 1);
l1 = element_max_edge_length( el );
g_return_val_if_fail( fabs( l1 - 2.0) < SMALL_NUMBER, 1);
element_angles( el, &a1, &a2, &a3 );
g_return_val_if_fail( fabs( a1 - G_PI/3.0) < SMALL_NUMBER, 1);
g_return_val_if_fail( fabs( a2 - G_PI/2.0) < SMALL_NUMBER, 1);
g_return_val_if_fail( fabs( a3 - G_PI/6.0) < SMALL_NUMBER, 1);
a1 = element_maximum_angle( el );
g_return_val_if_fail( fabs( a1 - G_PI/2.0) < SMALL_NUMBER, 1);
a1 = element_minimum_angle( el );
g_return_val_if_fail( fabs( a1 - G_PI/6.0) < SMALL_NUMBER, 1);
element_circumcenter_coordinates( el, &p );
g_return_val_if_fail( fabs( p.x - sqrt( 3.0 )/2.0 ) < SMALL_NUMBER, 1);
g_return_val_if_fail( fabs( p.y - 1.0/2.0 ) < SMALL_NUMBER, 1);
point2_set( NODE_POSITION( n3 ), 3.0, 0.0 );
a1 = element_area( el );
g_return_val_if_fail( fabs( a1 - 3.0/2.0) < SMALL_NUMBER, 1);
return 0;
}
static val_ptr run_pairing(val_ptr v[]) {
element_ptr x = v[0]->elem;
element_ptr e = element_new(x->field->pairing->GT);
element_pairing(e, x, v[1]->elem);
return val_new_element(e);
}
