[BACK]Return to ntl.cpp CVS log [TXT][DIR] Up to [local] / OpenXM / src / ox_ntl

Diff for /OpenXM/src/ox_ntl/ntl.cpp between version 1.1 and 1.5

version 1.1, 2003/11/03 03:11:21 version 1.5, 2004/07/04 02:31:51
Line 1 
Line 1 
 /* $OpenXM$ */  /* $OpenXM: OpenXM/src/ox_ntl/ntl.cpp,v 1.4 2003/11/17 12:04:20 iwane Exp $ */
   
 #include <NTL/ZZXFactoring.h>  #include <NTL/ZZXFactoring.h>
 #include <NTL/ZZ_pXFactoring.h>  #include <NTL/LLL.h>
   
 #include <iostream>  #include "ox_toolkit.h"
 #include <strstream>  
   
 #include "ntl.h"  #include "ntl.h"
   
   #if __NTL_DEBUG
   #define __NTL_PRINT (1)
   #endif
   
 /*==========================================================================*  #define DPRINTF(x)      printf x; fflush(stdout)
  * Check string format  
  *==========================================================================*/  
   
 #define NtlIsSpace(c)  ((c) == ' ' || (c) == '\t')  
 #define NtlIsDigit(c)  ((c) >= '0' && (c) <= '9')  
   
 /****************************************************************************  /****************************************************************************
  *   *
  * test for string format of integer   * Factorize polynomial over the integers.
  *   *
  * PARAM : I : str    : string   * PARAM : I : arg  : polynomial
  *       : O : endptr :   *       : I : argc :
  * RETURN: !0         : the string tests true   * RETURN: [num,[[factor1,multiplicity1],[factor2,multiplicity2],...]]
  *       :  0         : the string tests false  
  *   *
    * EX    : ntl_fctr([2*x^11+4*x^8-2*x^6+2*x^5-4*x^3-2],1) ==>
            : [2,[[x-1,1],[x^4+x^3+x^2+x+1,1],[x+1,2],[x^2-x+1,2]]]
    *
  ****************************************************************************/   ****************************************************************************/
 static int  cmo *
 ntl_isZZstr_(const char *str, char const **endptr)  ntl_fctr(cmo **arg, int argc)
 {  {
         while (NtlIsSpace(*str))          cmo *poly = arg[0];
                 str++;          cmo_indeterminate *x;
           ZZX f;
           int ret;
   
         /* NTL reject "+999"  */          if (argc != 1) {
         if (*str == '-')                  return ((cmo *)new_cmo_error2((cmo *)new_cmo_string("Invalid Parameter(#)")));
                 str++;          }
   
         if (!NtlIsDigit(*str))          ret = cmo_to_ZZX(f, poly, x);
                 return (0);          if (ret != NTL_SUCCESS) {
                   /* format error */
                   return ((cmo *)new_cmo_error2((cmo *)new_cmo_string("Invalid Parameter(type)")));
           }
   
         str++;  #if __NTL_PRINT
           cout << "input: " << f << endl;
   #endif
   
         while (NtlIsDigit(*str))          cmon_factors_t *factors = new_cmon_factors();
                 str++;          factors->x = x;
   
         *endptr = str;          factor(*factors->cont, *factors->f, f);
   
         return (!0);  #if __NTL_PRINT
           cout << "fctr : " << *factors->f << endl;
   #endif
   
 }  
   
 static int          return ((cmo *)factors);
 ntl_isZZstr(const char *str)  
 {  
         const char *ptr;  
         int ret = ntl_isZZstr_(str, &ptr);  
         if (!ret)  
                 return (ret);  
   
         while (NtlIsSpace(*ptr))  
                 ptr++;  
   
         return (*ptr == '\0');  
 }  }
   
   
 /****************************************************************************  /****************************************************************************
  *   *
  * test for string format of univariate polynomials with integer coefficients   * Factorize polynomial over the integers.
  * in NTL style.  
  *   *
  * PARAM : I : str    : string   * PARAM : I : arg  : polynomial
  *       : O : endptr :   *       : I : argc :
  * RETURN: !0         : the string tests true   * RETURN: [num,[[factor1,multiplicity1],[factor2,multiplicity2],...]]
  *       :  0         : the string tests false  
  *   *
    * EX    : ntl_fctr([2*x^11+4*x^8-2*x^6+2*x^5-4*x^3-2],1) ==>
            : [2,[[x-1,1],[x^4+x^3+x^2+x+1,1],[x+1,2],[x^2-x+1,2]]]
    *
  ****************************************************************************/   ****************************************************************************/
 static int  cmo *
 ntl_isZZXstr_(const char *str, char const **endptr)  ntl_lll(cmo **arg, int argc)
 {  {
         const char *s;          ZZX f;
           int ret;
           cmon_mat_zz_t *mat;
   
         while (NtlIsSpace(*str))          if (argc != 1) {
                 str++;                  return ((cmo *)new_cmo_error2((cmo *)new_cmo_string("Invalid Parameter(#)")));
           }
   
         if (*str != '[')          mat = new_cmon_mat_zz();
                 return (0);          ret = cmo_to_mat_zz(*mat->mat, arg[0]);
           if (ret != NTL_SUCCESS) {
         str++;                  delete_cmon_mat_zz(mat);
                   /* format error */
         while (*str != ']' && *str != '\0') {                  return ((cmo *)new_cmo_error2((cmo *)new_cmo_string("Invalid Parameter(type)")));
   
                 if (!ntl_isZZstr_(str, &s))  
                         return (0);  
                 str = s;  
   
                 while (NtlIsSpace(*str))  
                         str++;  
         }          }
   
         while (NtlIsSpace(*str))  #if __NTL_PRINT
                 str++;          cout << "input: " << (*mat->mat) << endl;
   #endif
   
         if (*str != ']')          ZZ det2;
                 return (0);          mat_ZZ U;
           long rd = LLL(det2, *mat->mat, U);
   
         str++;  #if __NTL_PRINT
         *endptr = str;          cout << "output: " << (*mat->mat) << endl;
         return (!0);          cout << U << endl;
 }  #endif
   
 static int          return ((cmo *)mat);
 ntl_isZZXstr(const char *str)  
 {  
         const char *ptr;  
         int ret = ntl_isZZXstr_(str, &ptr);  
         if (!ret)  
                 return (ret);  
   
         while (NtlIsSpace(*ptr))  
                 ptr++;  
   
         return (*ptr == '\0');  
 }  }
   
   
 /*==========================================================================*  
  * Convert  
  *==========================================================================*/  
 static cmo_zz *  
 ZZ_to_cmo_zz(const ZZ &z)  
 {  
         cmo_zz *c;  
   
         ostrstream sout;  #if __NTL_DEBUG /*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
         sout << z << '\0';  
   
         c = new_cmo_zz_set_string(sout.str());  #include <unistd.h>
   #include <gc/gc.h>
   #include <strstream>
   #include "gmp.h"
   
         return (c);  void ntl_free(void *ptr, size_t size) {}
 }  
   
   void *ntl_realloc(void *org, size_t old, size_t size)
 static int  
 cmo_to_ZZ(ZZ &z, cmo *c)  
 {  {
         int ret = NTL_SUCCESS;          void *ptr = GC_realloc(org, size);
         char *str;          return (ptr);
   
         switch (c->tag) {  
         case CMO_ZERO:  
                 z = to_ZZ(0);  
                 break;  
         case CMO_ZZ:  
         {  
                 str = new_string_set_cmo(c);  
                 istrstream sin(str, strlen(str));  
                 sin >> z;  
                 break;  
         }  
         case CMO_INT32:  
                 z = to_ZZ(((cmo_int32 *)c)->i);  
                 break;  
         case CMO_STRING:  
         {  
                 str = ((cmo_string *)c)->s;  
                 if (!ntl_isZZstr(str))  
                         return (NTL_FAILURE);  
   
                 istrstream sin(str, strlen(str));  
                 sin >> z;  
                 break;  
         }  
         default:  
                 ret = NTL_FAILURE;  
                 break;  
         }  
   
         return (ret);  
 }  }
   
   
 static int  int
 cmo_to_ZZX(ZZX &f, cmo *m, cmo_indeterminate *&x)  main(int argc, char *argv[])
 {  {
         char *str;  #if 0
         int ret;  
   
         switch (m->tag) {  
         case CMO_STRING:   /* [ 3 4 7 ] ==> 3+4*x+7*x^2 */  
                 str = ((cmo_string *)m)->s;  
                 ret = 0; //ntl_isZZXstr(str);  
   
                 if (!ret) {  
                         /* format error */  
                         return (NTL_FAILURE);  
                 }  
   
                 {  
                         istrstream sin(str, strlen(str));  
                         sin >> f;  
                 }  
                 break;  
         case CMO_RECURSIVE_POLYNOMIAL:  
         {  
                 cmo_recursive_polynomial *rec = (cmo_recursive_polynomial *)m;  
                 cmo_polynomial_in_one_variable *poly = (cmo_polynomial_in_one_variable *)rec->coef;  
                 cell *el;  
                 int len;  
   
                 if (poly->tag != CMO_POLYNOMIAL_IN_ONE_VARIABLE) {  
                         return (NTL_FAILURE);  
                 }  
   
                 el = list_first((cmo_list *)poly);  
                 len = list_length((cmo_list *)poly);  
   
                 f = 0;  
   
                 while (!list_endof((cmo_list *)poly, el)) {  
                         ZZ c;  
                         ostrstream sout;  
                         cmo *coef = el->cmo;  
                         int exp = el->exp;  
   
                         ret = cmo_to_ZZ(c, coef);  
                         if (ret != NTL_SUCCESS) {  
                                 return (NTL_FAILURE);  
                         }  
   
                         SetCoeff(f, exp, c);  
   
                         el = list_next(el);  
                 }  
   
   
                 el = list_first(rec->ringdef);  
                 x = (cmo_indeterminate *)el->cmo;  
   
                 break;  
         }  
         default:  
                 break;  
         }  
         return (NTL_SUCCESS);  
 }  
   
 /****************************************************************************  
  *  
  *  
  *  
  * PARAM : I : arg  : polynomial  
  *       : I : argc :  
  * RETURN: [[num, 1],[factor1,multiplicity1],[factor2,multiplicity2],...]  
  *  
  * EX    :  
  *  
  ****************************************************************************/  
 static cmo_recursive_polynomial *  
 ZZX_to_cmo(ZZX &factor, cmo_indeterminate *x)  
 {  {
         cmo_recursive_polynomial *rec;          ZZX f;
         cmo_polynomial_in_one_variable *poly;          const char *str = "12345";
           int num = 1;
           char *var = "x";
           cmo *c;
   
         cmo_list *ringdef;          f = to_ZZ(str);;
         int i;  
         cmo *coef;  
   
         ringdef = new_cmo_list();          cmo_indeterminate *x = new_cmo_indeterminate((cmo *)new_cmo_string(var));
         list_append(ringdef, (cmo *)x);          cmo_recursive_polynomial *poly = ZZX_to_cmo(f, x);
           cmo *arg[3];
   
         poly = new_cmo_polynomial_in_one_variable(0);          arg[0] = (cmo *)poly;
         for (i = deg(factor); i >= 0; i--) {  
                 if (coeff(factor, i) == 0)  
                         continue;  
   
                 coef = (cmo *)ZZ_to_cmo_zz(coeff(factor, i));          c = ntl_fctr(arg, num);
                 list_append_monomial((cmo_list *)poly, coef, i);  
         }  
   
         rec = new_cmo_recursive_polynomial(ringdef, (cmo *)poly);  
         return (rec);  
 }  }
   #endif
   
   
 static cmo_list *  
 new_cmo_pair_ZZX_int(ZZX &factors, int d, cmo_indeterminate *x)  
 {  {
         cmo_recursive_polynomial *poly;          cmo_zz *n;
         cmo_int32 *deg;  
         cmo_list *list;          istrstream istr("[3 -3 -6]");
           ZZ cont;
           ZZX fac;
           vec_pair_ZZX_long facs;
           cmo_indeterminate *x = new_cmo_indeterminate((cmo *)new_cmo_string("x"));
           istr >> fac;
   
         poly = ZZX_to_cmo(factors, x);          factor(cont, facs, fac);
         deg = new_cmo_int32(d);  
   
         list = list_appendl(NULL, poly, deg, NULL);          //      mpz_clear(ppp->mpz);
           mp_set_memory_functions(GC_malloc, ntl_realloc, ntl_free);
           for (int i = 0;; i++) {
   
         return (list);                  cmon_factors_t *mat = new_cmon_factors(cont, facs, x);
 }                  cmo *aaa = convert_cmon((cmo *)mat);
                   delete_cmon((cmo *)mat);
   
                   if (i % 1000 == 0) {
 /****************************************************************************                          printf("GC-counts: %d,   size: %u\n", GC_gc_no, GC_get_heap_size());
  *                          GC_gcollect();
  * convert vec_pair_ZZX_long(list of factor and multiplicity) to cmo_list                          usleep(1);
  *                  }
  * PARAM : I : factors : list of factor and multiplicity  
  *       :   :         :  [[factor1,multiplicity1][factor2,multiplicity2]...]  
  *       : I : x       : indeterminate  
  * RETURN:  
  *  
  ****************************************************************************/  
 static cmo_list *  
 factors_to_cmo(vec_pair_ZZX_long &factors, cmo_indeterminate *x)  
 {  
         int i;  
         cmo_list *list = new_cmo_list();  
         cmo_list *factor;  
   
         for (i = 0; i < factors.length(); i++) {  
                 factor = new_cmo_pair_ZZX_int(factors[i].a, factors[i].b, x);  
                 list_append(list, (cmo *)factor);  
         }          }
   
         return (list);  
 }  }
   
   
 /****************************************************************************          return (0);
  *  
  * Factorize polynomial over the integers.  
  *  
  * PARAM : I : arg  : polynomial  
  *       : I : argc :  
  * RETURN: [num,[[factor1,multiplicity1],[factor2,multiplicity2],...]]  
  *  
  * EX    : ntl_fctr([2*x^11+4*x^8-2*x^6+2*x^5-4*x^3-2],1) ==>  
          : [2,[[x-1,1],[x^4+x^3+x^2+x+1,1],[x+1,2],[x^2-x+1,2]]]  
  *  
  ****************************************************************************/  
 cmo *  
 ntl_fctr(cmo **arg, int argc)  
 {  
         cmo *poly = arg[0];  
         cmo_indeterminate *x;  
         ZZX f;  
         ZZ c;  
   
         int ret;  
   
         vec_pair_ZZX_long factors;  
   
         cmo_list *ans;  
         cmo *fcts;  
   
         if (argc != 1) {  
                 return ((cmo *)new_cmo_error2((cmo *)new_cmo_string("Invalid Parameter(#)")));  
         }  
   
         ret = cmo_to_ZZX(f, poly, x);  
         if (ret != NTL_SUCCESS) {  
                 /* format error */  
                 return ((cmo *)new_cmo_error2((cmo *)new_cmo_string("Invalid Parameter(type)")));  
         }  
   
         factor(c, factors, f);  
   
         cmo_zz *zz = ZZ_to_cmo_zz(c);  
   
         ans = new_cmo_list();  
   
         fcts = (cmo *)factors_to_cmo(factors, x);  
   
         list_appendl(ans, zz, (cmo *)fcts, NULL);  
   
         return ((cmo *)ans);  
 }  }
   
   #endif /* __NTL_DEBUG @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
   
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.5
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>