[BACK]Return to cmo.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / ox_toolkit

Diff for /OpenXM/src/ox_toolkit/cmo.c between version 1.13 and 1.25

version 1.13, 2003/06/05 21:12:07 version 1.25, 2015/08/18 02:24:04
Line 1 
Line 1 
 /* -*- mode: C; coding: euc-japan -*- */  /* -*- mode: C; coding: euc-japan -*- */
 /* $OpenXM: OpenXM/src/ox_toolkit/cmo.c,v 1.12 2003/06/03 16:06:48 ohara Exp $ */  /* $OpenXM: OpenXM/src/ox_toolkit/cmo.c,v 1.24 2015/08/17 05:18:35 noro Exp $ */
   
 /*  /*
    This module includes functions for sending/receiveng CMO's.     This module includes functions for sending/receiveng CMO's.
Line 11 
Line 11 
 #include <stdlib.h>  #include <stdlib.h>
 #include <stdarg.h>  #include <stdarg.h>
 #include <string.h>  #include <string.h>
   #include <mpfr.h>
 #include "ox_toolkit.h"  #include "ox_toolkit.h"
 #include "parse.h"  #include "parse.h"
   
Line 165  cmo_list* new_cmo_list()
Line 166  cmo_list* new_cmo_list()
     return c;      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* new_cmo_monomial32()
 {  {
     cmo_monomial32* c = MALLOC(sizeof(cmo_monomial32));      cmo_monomial32* c = MALLOC(sizeof(cmo_monomial32));
Line 225  cmo_zz* new_cmo_zz_size(int size)
Line 246  cmo_zz* new_cmo_zz_size(int size)
     return c;      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_BIGFLOAT;
       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* new_cmo_zero()
 {  {
     cmo_zero* m = MALLOC_ATOMIC(sizeof(cmo_zero));      cmo_zero* m = MALLOC_ATOMIC(sizeof(cmo_zero));
Line 235  cmo_zero* new_cmo_zero()
Line 310  cmo_zero* new_cmo_zero()
 cmo_double *new_cmo_double(double d)  cmo_double *new_cmo_double(double d)
 {  {
     cmo_double* m = MALLOC_ATOMIC(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;      m->d = d;
     return m;      return m;
 }  }
Line 274  cmo_distributed_polynomial* new_cmo_distributed_polyno
Line 349  cmo_distributed_polynomial* new_cmo_distributed_polyno
     return c;      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* new_cmo_error2(cmo* ob)
 {  {
     cmo_error2* c = MALLOC(sizeof(cmo_error2));      cmo_error2* c = MALLOC(sizeof(cmo_error2));
Line 327  static char *new_string_set_cmo_list(cmo_list *m)
Line 441  static char *new_string_set_cmo_list(cmo_list *m)
         strcat(s, sp[i]);          strcat(s, sp[i]);
         strcat(s, " , ");          strcat(s, " , ");
     }      }
     strcat(s, sp[len-1]);      if (len > 0)
         strcat(s, sp[len-1]);
     strcat(s, " ]");      strcat(s, " ]");
     return s;      return s;
 }  }
Line 357  char *new_string_set_cmo(cmo *m)
Line 472  char *new_string_set_cmo(cmo *m)
         return new_string_set_cmo_null();          return new_string_set_cmo_null();
     case CMO_LIST:      case CMO_LIST:
         return new_string_set_cmo_list((cmo_list *)m);          return new_string_set_cmo_list((cmo_list *)m);
         case CMO_64BIT_MACHINE_DOUBLE:      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:      default:
         ox_printf("unconvertible <%s>\n", get_symbol_by_tag(m->tag));          ox_printf("unconvertible <%s>\n", get_symbol_by_tag(m->tag));
         /* yet not implemented. */          /* yet not implemented. */
         return NULL;          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;
     }
 }  }

Legend:
Removed from v.1.13  
changed lines
  Added in v.1.25

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