===================================================================
RCS file: /home/cvs/OpenXM/src/ox_toolkit/cmo.c,v
retrieving revision 1.12
retrieving revision 1.26
diff -u -p -r1.12 -r1.26
--- OpenXM/src/ox_toolkit/cmo.c	2003/06/03 16:06:48	1.12
+++ OpenXM/src/ox_toolkit/cmo.c	2016/06/29 05:07:23	1.26
@@ -1,5 +1,5 @@
 /* -*- 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.25 2015/08/18 02:24:04 noro Exp $ */
 
 /* 
    This module includes functions for sending/receiveng CMO's.
@@ -11,6 +11,7 @@
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
+#include <mpfr.h>
 #include "ox_toolkit.h"
 #include "parse.h"
 
@@ -120,7 +121,7 @@ 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;
 }
@@ -128,8 +129,8 @@ cmo_null* new_cmo_null()
 cmo_int32* new_cmo_int32(int i)
 {
     cmo_int32* c;
-    c = MALLOC(sizeof(cmo_int32));
-    c->tag     = CMO_INT32;
+    c = MALLOC_ATOMIC(sizeof(cmo_int32));
+    c->tag = CMO_INT32;
     c->i = i;
     return c;
 }
@@ -139,7 +140,7 @@ 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;
@@ -165,6 +166,26 @@ cmo_list* new_cmo_list()
     return c;
 }
 
+cmo_list* new_cmo_list_array(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_array_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));
@@ -225,24 +246,78 @@ cmo_zz* new_cmo_zz_size(int size)
     return c;
 }
 
+cmo_qq* new_cmo_qq()
+{
+    cmo_qq* c = MALLOC(sizeof(cmo_qq));
+    c->tag  = CMO_QQ;
+    mpq_init(c->mpq);
+    return c;
+}
+
+cmo_bf* new_cmo_bf()
+{
+    cmo_bf* c = MALLOC(sizeof(cmo_bf));
+    c->tag = CMO_BIGFLOAT32;
+    mpfr_init(c->mpfr);
+    return c;
+}
+
+cmo_complex* new_cmo_complex()
+{
+    cmo_complex* c = MALLOC(sizeof(cmo_complex));
+    c->tag = CMO_COMPLEX;
+    return c;
+}
+
+cmo_qq* new_cmo_qq_set_mpq(mpq_ptr q)
+{
+    cmo_qq* c = new_cmo_qq();
+    mpq_set(c->mpq, q);
+    return c;
+}
+
+cmo_qq* new_cmo_qq_set_mpz(mpz_ptr num, mpz_ptr den)
+{
+    cmo_qq* c = new_cmo_qq();
+    mpq_set_num(c->mpq, num);
+    mpq_set_den(c->mpq, den);
+    return c;
+}
+
+cmo_bf* new_cmo_bf_set_mpfr(mpfr_ptr num)
+{
+    cmo_bf* c = new_cmo_bf();
+    mpfr_init2(c->mpfr,num->_mpfr_prec);
+    mpfr_set(c->mpfr,num,MPFR_RNDN);
+    return c;
+}
+
+cmo_complex* new_cmo_complex_set_re_im(cmo *re,cmo *im)
+{
+    cmo_complex* c = new_cmo_complex();
+    c->re = re;
+    c->im = im;
+    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));
-    m->tag = CMO_64BIT_MACHINE_DOUBLE;
+    cmo_double* m = MALLOC_ATOMIC(sizeof(cmo_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;
 }
@@ -274,6 +349,45 @@ 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));
@@ -327,7 +441,8 @@ 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;
 }
@@ -337,8 +452,8 @@ static char *new_string_set_cmo_double(cmo_double *m)
     char buff[1024];
     char *s;
 
-    sprintf(buff, "%lf", m->d);
-    s = MALLOC(strlen(buff)+1);
+    sprintf(buff, "%.20f", m->d);
+    s = MALLOC_ATOMIC(strlen(buff)+1);
     strcpy(s, buff);
 
     return s;
@@ -357,11 +472,26 @@ 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_64BIT_MACHINE_DOUBLE:
+    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. */
         return NULL;
     }
+}
+
+int cmo_to_int(cmo *n)
+{
+  switch(n->tag) {
+    case CMO_ZERO:
+      return 0;
+    case CMO_INT32:
+      return ((cmo_int32 *)n)->i;
+    case CMO_ZZ:
+      return mpz_get_si(((cmo_zz *)n)->mpz);
+    default:
+      return 0;
+  }
 }