OpenXM/src/ox_toolkit/cmo.c - diff

Return to cmo.c CVS log

Up to [local] / OpenXM / src / ox_toolkit

Diff for /OpenXM/src/ox_toolkit/cmo.c between version 1.12 and 1.20

version 1.12, 2003/06/03 16:06:48

version 1.20, 2005/07/26 12:52:04

Line 1

/* -*- mode: C; coding: euc-japan -*- */

/* $OpenXM: OpenXM/src/ox_toolkit/cmo.c,v 1.11 2003/06/02 10:25:56 ohara Exp $ */

/* $OpenXM: OpenXM/src/ox_toolkit/cmo.c,v 1.19 2005/07/20 17:48:03 ohara Exp $ */

This module includes functions for sending/receiveng CMO's.

Line 110 cmo *list_nth(cmo_list* this, int n)

return NULL;

}

void **list_to_array(cmo_list *c)

{

int i;

int n = list_length(c);

void **array = MALLOC(sizeof(void *)*(n+1));

for(i=0; i<n; i++) {

array[i] = list_nth(c, i);

}

array[n] = NULL;

return array;

}

void **list_to_array_map(cmo_list *c, void *(* mapf)(void *))

{

int i;

int n = list_length(c);

void **array = MALLOC(sizeof(void *)*(n+1));

for(i=0; i<n; i++) {

array[i] = mapf(list_nth(c, i));

}

array[n] = NULL;

return array;

}

/* for GNU mpz */

void resize_mpz(mpz_ptr mpz, int size)

{

Line 120 void resize_mpz(mpz_ptr mpz, int size)

Line 144 void resize_mpz(mpz_ptr mpz, int size)

/* functions named new_cmo_*. */

cmo_null* new_cmo_null()

{

cmo_null* m = MALLOC(sizeof(cmo_null));

cmo_null* m = MALLOC_ATOMIC(sizeof(cmo_null));

m->tag = CMO_NULL;

return m;

}

Line 128 cmo_null* new_cmo_null()

Line 152 cmo_null* new_cmo_null()

cmo_int32* new_cmo_int32(int i)

{

cmo_int32* c;

c = MALLOC(sizeof(cmo_int32));

c = MALLOC_ATOMIC(sizeof(cmo_int32));

c->tag = CMO_INT32;

c->i = i;

return c;

}

Line 139 cmo_string* new_cmo_string(char* s)

Line 163 cmo_string* new_cmo_string(char* s)

cmo_string* c = MALLOC(sizeof(cmo_string));

c->tag = CMO_STRING;

if (s != NULL) {

c->s = MALLOC(strlen(s)+1);

c->s = MALLOC_ATOMIC(strlen(s)+1);

strcpy(c->s, s);

}else {

c->s = NULL;

Line 165 cmo_list* new_cmo_list()

Line 189 cmo_list* new_cmo_list()

return c;

}

cmo_list* new_cmo_list_set(void *array[], int n)

{

int i;

cmo_list* c = new_cmo_list();

for(i=0; i<n; i++) {

list_append(c, array[i]);

}

return c;

}

cmo_list* new_cmo_list_map(void *array[], int n, void *(* mapf)(void *))

{

int i;

cmo_list* c = new_cmo_list();

for(i=0; i<n; i++) {

list_append(c, (cmo *)mapf(array[i]));

}

return c;

}

cmo_monomial32* new_cmo_monomial32()

{

cmo_monomial32* c = MALLOC(sizeof(cmo_monomial32));

Line 225 cmo_zz* new_cmo_zz_size(int size)

Line 269 cmo_zz* new_cmo_zz_size(int size)

return c;

}

cmo_qq* new_cmo_qq_noinit()

{

cmo_qq* c = MALLOC(sizeof(cmo_qq));

c->tag = CMO_QQ;

c->num = c->den = NULL;

return c;

}

cmo_qq* new_cmo_qq_set_mpq(mpq_ptr q)

{

cmo_qq* c = new_cmo_qq_noinit();

c->num = new_cmo_zz_set_mpz(mpq_numref(q));

c->den = new_cmo_zz_set_mpz(mpq_denref(q));

return c;

}

cmo_qq* new_cmo_qq_set_mpz(mpz_ptr num, mpz_ptr den)

{

cmo_qq* c = new_cmo_qq_noinit();

c->num = new_cmo_zz_set_mpz(num);

c->den = new_cmo_zz_set_mpz(den);

return c;

}

cmo_zero* new_cmo_zero()

{

cmo_zero* m = MALLOC(sizeof(cmo_zero));

cmo_zero* m = MALLOC_ATOMIC(sizeof(cmo_zero));

m->tag = CMO_ZERO;

return m;

}

cmo_double *new_cmo_double(double d)

{

cmo_double* m = MALLOC(sizeof(cmo_double));

cmo_double* m = MALLOC_ATOMIC(sizeof(cmo_double));

m->tag = CMO_64BIT_MACHINE_DOUBLE;

m->tag = CMO_IEEE_DOUBLE_FLOAT;

m->d = d;

return m;

}

cmo_dms_generic* new_cmo_dms_generic()

{

cmo_dms_generic* m = MALLOC(sizeof(cmo_dms_generic));

cmo_dms_generic* m = MALLOC_ATOMIC(sizeof(cmo_dms_generic));

m->tag = CMO_DMS_GENERIC;

return m;

}

Line 274 cmo_distributed_polynomial* new_cmo_distributed_polyno

Line 342 cmo_distributed_polynomial* new_cmo_distributed_polyno

return c;

}

cmo_polynomial_in_one_variable* new_cmo_polynomial_in_one_variable(int var)

{

cmo_polynomial_in_one_variable* c = MALLOC(sizeof(cmo_polynomial_in_one_variable));

c->tag = CMO_POLYNOMIAL_IN_ONE_VARIABLE;

c->length = 0;

c->head->next = c->head;

c->head->prev = c->head;

c->var = var;

return c;

}

cmo_recursive_polynomial* new_cmo_recursive_polynomial(cmo_list* ringdef, cmo* coef)

{

cmo_recursive_polynomial* c = MALLOC(sizeof(cmo_recursive_polynomial));

c->tag = CMO_RECURSIVE_POLYNOMIAL;

c->ringdef = ringdef;

c->coef = coef;

return c;

}

cmo_tree* new_cmo_tree(cmo_string* name, cmo_list* attributes, cmo_list* leaves)

{

cmo_tree* c = MALLOC(sizeof(cmo_tree));

c->tag = CMO_TREE;

c->name= name;

c->attributes = attributes;

c->leaves = leaves;

return c;

}

cmo_lambda* new_cmo_lambda(cmo_list* args, cmo_tree* body)

{

cmo_lambda* c = MALLOC(sizeof(cmo_lambda));

c->tag = CMO_LAMBDA;

c->args = args;

c->body = body;

return c;

}

cmo_error2* new_cmo_error2(cmo* ob)

{

cmo_error2* c = MALLOC(sizeof(cmo_error2));

Line 327 static char *new_string_set_cmo_list(cmo_list *m)

Line 434 static char *new_string_set_cmo_list(cmo_list *m)

strcat(s, sp[i]);

strcat(s, " , ");

}

strcat(s, sp[len-1]);

if (len > 0)

strcat(s, sp[len-1]);

strcat(s, " ]");

return s;

}

Line 337 static char *new_string_set_cmo_double(cmo_double *m)

Line 445 static char *new_string_set_cmo_double(cmo_double *m)

char buff[1024];

char *s;

sprintf(buff, "%lf", m->d);

sprintf(buff, "%.20f", m->d);

s = MALLOC(strlen(buff)+1);

s = MALLOC_ATOMIC(strlen(buff)+1);

strcpy(s, buff);

return s;

Line 357 char *new_string_set_cmo(cmo *m)

Line 465 char *new_string_set_cmo(cmo *m)

return new_string_set_cmo_null();

case CMO_LIST:

return new_string_set_cmo_list((cmo_list *)m);

case CMO_64BIT_MACHINE_DOUBLE:

return new_string_set_cmo_int32(m);

case CMO_IEEE_DOUBLE_FLOAT:

return new_string_set_cmo_double((cmo_double *)m);

default:

ox_printf("unconvertible <%s>\n", get_symbol_by_tag(m->tag));

/* yet not implemented. */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>