Changeset 7fee876 in git
- Timestamp:
- Mar 16, 2012, 9:26:19 PM (12 years ago)
- Branches:
- (u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b4f17ed1d25f93d46dbe29e4b499baecc2fd51bb')
- Children:
- 5a72fe43aa1fbae0fb93ebbff5685375e726f93c
- Parents:
- ce1f78b09d525de2d3babcf986a9f4821e60ed00
- git-author:
- Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-03-16 21:26:19+01:00
- git-committer:
- Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-03-17 05:41:42+01:00
- Files:
-
- 22 edited
Legend:
- Unmodified
- Added
- Removed
-
Singular/ipshell.cc
rce1f78 r7fee876 2074 2074 if (strcmp(rParameter(R)[i],R->names[j])==0) 2075 2075 { 2076 Warn("name conflict par(%d) and var(%d): `%s`, rename to `@@(%d)`",i+1,j+1,R->names[j],i+1); 2077 omFree(rParameter(R)[i]); 2078 rParameter(R)[i]=(char *)omAlloc(10); 2079 sprintf(rParameter(R)[i],"@@(%d)",i+1); 2076 Warn("name conflict par(%d) and var(%d): `%s`, renaming the VARIABLE to `@@(%d)`",i+1,j+1,R->names[j],i+1); 2077 // omFree(rParameter(R)[i]); 2078 // rParameter(R)[i]=(char *)omAlloc(10); 2079 // sprintf(rParameter(R)[i],"@@(%d)",i+1); 2080 2081 omFree(R->names[j]); 2082 R->names[j]=(char *)omAlloc(10); 2083 sprintf(R->names[j],"@@(%d)",i+1); 2080 2084 } 2081 2085 } -
Singular/walk.cc
rce1f78 r7fee876 1943 1943 res->VarOffset = NULL; 1944 1944 res->ref=0; 1945 if (currRing->cf->extRing!=NULL) 1946 currRing->cf->extRing->ref++; 1947 1948 if (rParameter (currRing)!=NULL) 1949 { 1950 res->cf->extRing->minideal->m[0]=p_Copy(currRing->cf->extRing->minideal->m[0],currRing->cf->extRing); 1951 int l=rPar(currRing); 1952 res->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr)); 1953 1954 for(i=l-1;i>=0;i--) 1955 rParameter (res)[i]=omStrDup(rParameter (currRing)[i]); 1956 } 1945 1946 res->cf = currRing->cf; currRing->cf->ref++; 1947 1948 // if (currRing->cf->extRing!=NULL) 1949 // currRing->cf->extRing->ref++; 1950 // 1951 // if (rParameter (currRing)!=NULL) 1952 // { 1953 // res->cf->extRing->minideal->m[0]=p_Copy(currRing->cf->extRing->minideal->m[0],currRing->cf->extRing); 1954 // int l=rPar(currRing); 1955 // 1956 // res->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr)); 1957 // 1958 // for(i=l-1;i>=0;i--) 1959 // rParameter (res)[i]=omStrDup(rParameter (currRing)[i]); 1960 // } 1957 1961 1958 1962 intvec* iva = va; … … 2022 2026 r->VarOffset = NULL; 2023 2027 r->ref=0; 2024 if (currRing->cf->extRing!=NULL) 2025 currRing->cf->extRing->ref++; 2026 2027 if (rParameter (currRing)!=NULL) 2028 { 2029 r->cf->extRing->minideal->m[0]=p_Copy(currRing->cf->extRing->minideal->m[0], currRing->cf->extRing); 2030 int l=rPar(currRing); 2031 r->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr)); 2032 2033 for(i=l-1;i>=0;i--) 2034 rParameter(r)[i]=omStrDup(rParameter (currRing)[i]); 2035 } 2028 2029 r->cf = currRing->cf; currRing->cf->ref++; 2030 2031 // if (currRing->cf->extRing!=NULL) 2032 // currRing->cf->extRing->ref++; 2033 // 2034 // if (rParameter (currRing)!=NULL) 2035 // { 2036 // r->cf->extRing->minideal->m[0]=p_Copy(currRing->cf->extRing->minideal->m[0], currRing->cf->extRing); 2037 // int l=rPar(currRing); 2038 // r->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr)); 2039 // 2040 // for(i=l-1;i>=0;i--) 2041 // rParameter(r)[i]=omStrDup(rParameter (currRing)[i]); 2042 // } 2036 2043 2037 2044 … … 2073 2080 2074 2081 2075 if (rParameter(currRing)!=NULL)2076 {2077 r->cf->extRing->minideal->m[0]=p_Copy(currRing->cf->extRing->minideal->m[0], currRing->cf->extRing);2078 int l=rPar(currRing);2079 r->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr));2080 2081 for(i=l-1;i>=0;i--)2082 rParameter(r)[i]=omStrDup(rParameter(currRing)[i]);2083 }2082 // if (rParameter(currRing)!=NULL) 2083 // { 2084 // r->cf->extRing->minideal->m[0]=p_Copy(currRing->cf->extRing->minideal->m[0], currRing->cf->extRing); 2085 // int l=rPar(currRing); 2086 // r->cf->extRing->names=(char **)omAlloc(l*sizeof(char_ptr)); 2087 // 2088 // for(i=l-1;i>=0;i--) 2089 // rParameter(r)[i]=omStrDup(rParameter(currRing)[i]); 2090 // } 2084 2091 2085 2092 /* complete ring intializations */ -
libpolys/coeffs/coeffs.h
rce1f78 r7fee876 195 195 int (*cfParDeg)(number x,const coeffs r); 196 196 197 /// create i^th parameter or NULL if not possible 198 number (*cfParameter)(const int i, const coeffs r); 199 197 200 #ifdef HAVE_FACTORY 198 201 number (*convFactoryNSingN)( const CanonicalForm n, const coeffs r); … … 213 216 n_coeffType type; 214 217 218 219 /// Number of Parameters in the coeffs (default 0) 220 int iNumberOfParameters; 221 222 /// array containing the names of Parameters (default NULL) 223 char const * const * pParameterNames; 224 // NOTE that it replaces the following: 225 // char* complex_parameter; //< the name of sqrt(-1) in n_long_C , i.e. 'i' or 'j' etc...? 226 // char * m_nfParameter; //< the name of parameter in n_GF 227 215 228 ///////////////////////////////////////////// 216 229 // the union stuff … … 227 240 228 241 //------------------------------------------- 229 char* complex_parameter; //< the name of sqrt(-1), i.e. 'i' or 'j' etc...?230 231 242 #ifdef HAVE_RINGS 232 243 /* The following members are for representing the ring Z/n, … … 282 293 unsigned short *m_nfPlus1Table; 283 294 int *m_nfMinPoly; 284 char * m_nfParameter; 285 295 286 296 // --------------------------------------------------- 287 297 // for Zp: … … 636 646 } 637 647 648 /// Returns the number of parameters 649 static inline int n_NumberOfParameters(const coeffs r){ return r->iNumberOfParameters; } 650 651 /// Returns a (const!) pointer to (const char*) names of parameters 652 static inline char const * const * n_ParameterNames(const coeffs r){ return r->pParameterNames; } 653 654 655 /// return the (iParameter^th) parameter as a NEW number 656 /// NOTE: parameter numbering: 1..n_NumberOfParameters(...) 657 static inline number n_Param(const int iParameter, const coeffs r) 658 { 659 assume(r != NULL); 660 assume((iParameter >= 1) || (iParameter <= n_NumberOfParameters(r))); 661 assume(r->cfParameter != NULL); 662 return r->cfParameter(iParameter, r); 663 } 664 665 638 666 static inline number n_Init_bigint(number i, const coeffs dummy, 639 667 const coeffs dst) -
libpolys/coeffs/ffields.cc
rce1f78 r7fee876 7 7 */ 8 8 9 #include "config.h" 10 11 #include <omalloc/omalloc.h> 12 9 13 #include <misc/auxiliary.h> 10 #include <string.h> 14 #include <misc/mylimits.h> 15 16 #include <reporter/reporter.h> 17 #include <resources/feFopen.h> 18 11 19 #include <coeffs/coeffs.h> 12 #include <misc/mylimits.h>13 #include <omalloc/omalloc.h>14 #include <reporter/reporter.h>15 20 #include <coeffs/numbers.h> 16 21 #include <coeffs/ffields.h> 17 #include <resources/feFopen.h> 22 23 #include <string.h> 18 24 #include <math.h> 19 25 26 BOOLEAN nfGreaterZero (number k, const coeffs r); 27 number nfMult (number a, number b, const coeffs r); 28 number nfInit (long i, const coeffs r); 29 number nfParameter (int i, const coeffs r); 30 int nfParDeg (number n, const coeffs r); 31 int nfInt (number &n, const coeffs r); 32 number nfAdd (number a, number b, const coeffs r); 33 number nfSub (number a, number b, const coeffs r); 34 void nfPower (number a, int i, number * result, const coeffs r); 35 BOOLEAN nfIsZero (number a, const coeffs r); 36 BOOLEAN nfIsOne (number a, const coeffs r); 37 BOOLEAN nfIsMOne (number a, const coeffs r); 38 number nfDiv (number a, number b, const coeffs r); 39 number nfNeg (number c, const coeffs r); 40 number nfInvers (number c, const coeffs r); 41 BOOLEAN nfGreater (number a, number b, const coeffs r); 42 BOOLEAN nfEqual (number a, number b, const coeffs r); 43 const char * nfRead (const char *s, number *a, const coeffs r); 44 #ifdef LDEBUG 45 BOOLEAN nfDBTest (number a, const char *f, const int l, const coeffs r); 46 #endif 47 //void nfSetChar (const coeffs r); 48 49 nMapFunc nfSetMap (const coeffs src, const coeffs dst); 50 char * nfName (number n, const coeffs r); 51 void nfReadTable (const int c, const coeffs r); 52 53 void nfCoeffWrite(const coeffs r, BOOLEAN details); 54 void nfShowMipo(const coeffs r); 55 56 57 58 /// Our Type! 59 static const n_coeffType ID = n_GF; 20 60 21 61 //unsigned short *nfPlus1Table=NULL; /* the table i=log(z^i) -> log(z^i+1) */ … … 184 224 * the generating element `z` 185 225 */ 186 number nfPar (int i, const coeffs)226 number nfParameter (int i, const coeffs) 187 227 { 188 228 assume(i==1); 189 return (number)1; 229 230 if( i == 1 ) 231 return (number)1; 232 233 return NULL; 190 234 } 191 235 … … 394 438 else 395 439 { 396 StringAppendS( r->m_nfParameter);440 StringAppendS(n_ParameterNames(r)[0]); 397 441 if ((long)a!=1L) 398 442 { … … 416 460 else 417 461 { 418 StringAppendS( r->m_nfParameter);462 StringAppendS(n_ParameterNames(r)[0]); 419 463 if ((long)a!=1L) 420 464 { … … 433 477 #endif 434 478 char *s; 435 c har *nfParameter=r->m_nfParameter;479 const char * const nf_Parameter=n_ParameterNames(r)[0]; 436 480 if (((long)a==(long)r->m_nfCharQ) || ((long)a==0L)) return NULL; 437 481 else if ((long)a==1L) 438 482 { 439 return omStrDup(nf Parameter);483 return omStrDup(nf_Parameter); 440 484 } 441 485 else 442 486 { 443 s=(char *)omAlloc(4+strlen(nf Parameter));444 sprintf(s,"%s%d",nf Parameter,(int)((long)a));487 s=(char *)omAlloc(4+strlen(nf_Parameter)); 488 sprintf(s,"%s%d",nf_Parameter,(int)((long)a)); 445 489 } 446 490 return s; … … 513 557 *a = nfDiv(z,n,r); 514 558 } 515 char *nfParameter=r->m_nfParameter; 516 if (strncmp(s,nfParameter,strlen(nfParameter))==0) 517 { 518 s+=strlen(nfParameter); 559 const char * const nf_Parameter = n_ParameterNames(r)[0]; 560 const int N = strlen(nf_Parameter); 561 if (strncmp(s,nf_Parameter, N)==0) 562 { 563 s += N; 519 564 if ((*s >= '0') && (*s <= '9')) 520 565 { … … 573 618 j++; 574 619 if (nfMinPoly[j]!=0) 575 StringAppend("%d*%s^%d",nfMinPoly[j], r->m_nfParameter,i);620 StringAppend("%d*%s^%d",nfMinPoly[j],n_ParameterNames(r)[0],i); 576 621 i--; 577 622 if(i<0) break; … … 779 824 static BOOLEAN nfCoeffIsEqual(const coeffs, n_coeffType, void*); 780 825 826 static void nfKillChar(coeffs r) 827 { 828 char** p = (char**)n_ParameterNames(r); 829 830 const int P = n_NumberOfParameters(r); 831 832 for( int i = 1; i <= P; i++ ) 833 if (p[i-1] != NULL) 834 omFree( (ADDRESS)p[i-1] ); 835 836 omFreeSize((ADDRESS)p, P * sizeof(char*)); 837 } 838 781 839 BOOLEAN nfInitChar(coeffs r, void * parameter) 782 840 { 783 841 //r->cfInitChar=npInitChar; 784 //r->cfKillChar=nfKillChar;842 r->cfKillChar=nfKillChar; 785 843 r->nCoeffIsEqual=nfCoeffIsEqual; 786 844 … … 844 902 r->m_nfCharP = p->GFChar; 845 903 r->m_nfCharQ1 = 0; 846 r->m_nfParameter= omStrDup(name); //TODO use omAlloc for allocating memory and use strcpy? 904 905 r->iNumberOfParameters = 1; 906 r->cfParameter = nfParameter; 907 908 char ** pParameterNames = (char **) omAlloc0(sizeof(char *)); 909 pParameterNames[0] = omStrDup(name); //TODO use omAlloc for allocating memory and use strcpy? 910 911 assume( pParameterNames != NULL ); 912 assume( pParameterNames[0] != NULL ); 913 914 r->pParameterNames = pParameterNames; 915 // NOTE: r->m_nfParameter was replaced by n_ParameterNames(r)[0] 916 917 // TODO: nfKillChar MUST destroy r->pParameterNames[0] (0-term. string) && r->pParameterNames (array of size 1) 918 847 919 r->m_nfPlus1Table= NULL; 848 920 … … 893 965 // m_nfCharQ = p^k where p is the characteristic (r->CharP) and k is GFDegree 894 966 Print("// # ground field : %d\n",r->m_nfCharQ); 895 Print("// primitive element : %s\n", r->m_nfParameter);967 Print("// primitive element : %s\n", n_ParameterNames(r)[0]); 896 968 if ( details ) 897 969 { … … 908 980 GFInfo* p = (GFInfo *)(parameter); 909 981 int c = pow (p->GFChar, p->GFDegree); 910 if ((c == r->m_nfCharQ) && (strcmp( r->m_nfParameter,p->GFPar_name) == 0))982 if ((c == r->m_nfCharQ) && (strcmp(n_ParameterNames(r)[0], p->GFPar_name) == 0)) 911 983 return TRUE; 912 984 } -
libpolys/coeffs/ffields.h
rce1f78 r7fee876 8 8 * ABSTRACT: finite fields with a none-prime number of elements (via tables) 9 9 */ 10 #include < coeffs/coeffs.h>10 #include <misc/auxiliary.h> 11 11 12 struct n_Procs_s; 13 typedef struct n_Procs_s *coeffs; 14 15 //// Initialize r (n_GF) 12 16 BOOLEAN nfInitChar(coeffs r, void*); 13 17 14 BOOLEAN nfGreaterZero (number k, const coeffs r); 15 number nfMult (number a, number b, const coeffs r); 16 number nfInit (long i, const coeffs r); 17 number nfPar (int i, const coeffs r); 18 int nfParDeg (number n, const coeffs r); 19 int nfInt (number &n, const coeffs r); 20 number nfAdd (number a, number b, const coeffs r); 21 number nfSub (number a, number b, const coeffs r); 22 void nfPower (number a, int i, number * result, const coeffs r); 23 BOOLEAN nfIsZero (number a, const coeffs r); 24 BOOLEAN nfIsOne (number a, const coeffs r); 25 BOOLEAN nfIsMOne (number a, const coeffs r); 26 number nfDiv (number a, number b, const coeffs r); 27 number nfNeg (number c, const coeffs r); 28 number nfInvers (number c, const coeffs r); 29 BOOLEAN nfGreater (number a, number b, const coeffs r); 30 BOOLEAN nfEqual (number a, number b, const coeffs r); 31 void nfWrite (number &a, const coeffs r); 32 const char * nfRead (const char *s, number *a, const coeffs r); 33 #ifdef LDEBUG 34 BOOLEAN nfDBTest (number a, const char *f, const int l, const coeffs r); 18 /// Show the mininimal polynom.... 19 /// NOTE: this is used by char * sleftv::String(void *d, BOOLEAN typed, int dim) (from Singular/subexpr.cc) 20 /// TODO: rewrite this UGLYNESS!!! 21 void nfShowMipo(const coeffs r); 22 35 23 #endif 36 //void nfSetChar (const coeffs r);37 38 nMapFunc nfSetMap (const coeffs src, const coeffs dst);39 char * nfName (number n, const coeffs r);40 void nfReadTable (const int c, const coeffs r);41 42 void nfCoeffWrite(const coeffs r, BOOLEAN details);43 void nfShowMipo(const coeffs r);44 #endif -
libpolys/coeffs/gnumpc.cc
rce1f78 r7fee876 11 11 #include "config.h" 12 12 13 #include <omalloc/omalloc.h> 14 15 #include <misc/auxiliary.h> 16 #include <misc/mylimits.h> 17 18 #include <reporter/reporter.h> 19 #include <resources/feFopen.h> 20 13 21 #include <coeffs/coeffs.h> 14 22 #include <coeffs/numbers.h> 23 15 24 #include <coeffs/longrat.h> 16 25 #include <coeffs/modulop.h> 26 17 27 #include <coeffs/gnumpc.h> 18 28 #include <coeffs/gnumpfl.h> 29 #include <coeffs/shortfl.h> 30 19 31 #include <coeffs/mpr_complex.h> 20 #include <reporter/reporter.h> 21 #include <omalloc/omalloc.h> 22 23 24 #include <coeffs/shortfl.h> 32 33 34 /// Get a mapping function from src into the domain of this type: long_C! 35 nMapFunc ngcSetMap(const coeffs src, const coeffs dst); 36 37 number ngcMapQ(number from, const coeffs r, const coeffs aRing); 38 39 void ngcSetChar(const coeffs r); 40 41 // Private interface should be hidden!!! 42 43 /// Note: MAY NOT WORK AS EXPECTED! 44 BOOLEAN ngcGreaterZero(number za, const coeffs r); 45 BOOLEAN ngcGreater(number a, number b, const coeffs r); 46 BOOLEAN ngcEqual(number a, number b, const coeffs r); 47 BOOLEAN ngcIsOne(number a, const coeffs r); 48 BOOLEAN ngcIsMOne(number a, const coeffs r); 49 BOOLEAN ngcIsZero(number za, const coeffs r); 50 number ngcInit(long i, const coeffs r); 51 int ngcInt(number &n, const coeffs r); 52 number ngcNeg(number za, const coeffs r); 53 number ngcInvers(number a, const coeffs r); 54 number ngcParameter(int i, const coeffs r); 55 number ngcAdd(number la, number li, const coeffs r); 56 number ngcSub(number la, number li, const coeffs r); 57 number ngcMult(number a, number b, const coeffs r); 58 number ngcDiv(number a, number b, const coeffs r); 59 void ngcPower(number x, int exp, number *lu, const coeffs r); 60 number ngcCopy(number a, const coeffs r); 61 number ngc_Copy(number a, coeffs r); 62 const char * ngcRead (const char *s, number *a, const coeffs r); 63 void ngcWrite(number &a, const coeffs r); 64 number ngcRePart(number a, const coeffs r); 65 number ngcImPart(number a, const coeffs r); 66 67 void ngcDelete(number *a, const coeffs r); 68 void ngcCoeffWrite(const coeffs r, BOOLEAN details); 69 70 #ifdef LDEBUG 71 BOOLEAN ngcDBTest(number a, const char *f, const int l, const coeffs r); 72 #endif 73 74 75 // Why is this here? who needs it? 76 // number ngcMapQ(number from, const coeffs r, const coeffs aRing); 25 77 26 78 /// Our Type! … … 38 90 #endif 39 91 40 /* 41 number ngcPar(int i, const coeffs r) 92 number ngcParameter(int i, const coeffs r) 42 93 { 43 94 assume( getCoeffType(r) == ID ); 44 95 assume(i==1); 45 96 46 gmp_complex* n= new gmp_complex( (long)0, (long)1 ); 47 return (number)n; 48 } 49 */ 97 if( i == 1 ) 98 return (number)(new gmp_complex( (long)0, (long)1 )); 99 100 return NULL; // new gmp_complex( ) // 0? 101 } 50 102 51 103 /*2 … … 329 381 { 330 382 assume( getCoeffType(r) == ID ); 331 assume( r->complex_parameter != NULL ); 383 const char * const complex_parameter = n_ParameterNames(r)[0]; 384 assume( complex_parameter != NULL ); 385 const int N = strlen(complex_parameter); 332 386 333 387 if ((*s >= '0') && (*s <= '9')) … … 339 393 delete re; 340 394 } 341 else if (strncmp(s, r->complex_parameter,strlen(r->complex_parameter))==0)342 { 343 s +=strlen(r->complex_parameter);395 else if (strncmp(s, complex_parameter, N)==0) 396 { 397 s += N; 344 398 gmp_complex *aa=new gmp_complex((long)0,(long)1); 345 399 *a=(number)aa; … … 385 439 (p->float_len2 == r->float_len2) 386 440 ) 387 if (strcmp(p->par_name, r->complex_parameter) == 0)441 if (strcmp(p->par_name, n_ParameterNames(r)[0]) == 0) 388 442 return (TRUE); 389 443 } … … 391 445 } 392 446 447 static void ngcKillChar(coeffs r) 448 { 449 char** p = (char**)n_ParameterNames(r); 450 451 const int P = n_NumberOfParameters(r); 452 453 for( int i = 1; i <= P; i++ ) 454 if (p[i-1] != NULL) 455 omFree( (ADDRESS)p[i-1] ); 456 457 omFreeSize((ADDRESS)p, P * sizeof(char*)); 458 } 459 393 460 BOOLEAN ngcInitChar(coeffs n, void* parameter) 394 461 { 395 462 assume( getCoeffType(n) == ID ); 396 463 397 n->cfKillChar = n dKillChar; /* dummy */464 n->cfKillChar = ngcKillChar; 398 465 n->ch = 0; 399 466 … … 496 563 r->has_simple_Inverse=FALSE; 497 564 */ 498 565 566 n->iNumberOfParameters = 1; 567 n->cfParameter = ngcParameter; 568 569 char ** pParameterNames = (char **) omAlloc0(sizeof(char *)); 570 499 571 if( parameter != NULL) 500 572 { 501 573 LongComplexInfo* p = (LongComplexInfo*)parameter; 502 n->complex_parameter = omStrDup(p->par_name);574 pParameterNames[0] = omStrDup(p->par_name); //TODO use omAlloc for allocating memory and use strcpy? 503 575 n->float_len = p->float_len; 504 576 n->float_len2 = p->float_len2; … … 506 578 } else // default values, just for testing! 507 579 { 508 n->complex_parameter= omStrDup("i");580 pParameterNames[0] = omStrDup("i"); 509 581 n->float_len = SHORT_REAL_LENGTH; 510 582 n->float_len2 = SHORT_REAL_LENGTH; … … 513 585 assume( n->float_len <= n->float_len2 ); 514 586 assume( n->float_len2 >= SHORT_REAL_LENGTH ); 515 assume( n->complex_parameter != NULL ); 516 587 assume( pParameterNames != NULL ); 588 assume( pParameterNames[0] != NULL ); 589 590 n->pParameterNames = pParameterNames; 591 592 // NOTE: n->complex_parameter was replaced by n_ParameterNames(n)[0] 593 // TODO: nfKillChar MUST destroy n->pParameterNames[0] (0-term. string) && n->pParameterNames (array of size 1) 594 517 595 return FALSE; 518 596 } … … 623 701 Print("// characteristic : 0 (complex:%d digits, additional %d digits)\n", 624 702 r->float_len, r->float_len2); /* long C */ 625 Print("// 1 parameter : %s \n", r->complex_parameter);626 Print("// minpoly : (%s^2+1)\n", r->complex_parameter);627 } 703 Print("// 1 parameter : %s \n", n_ParameterNames(r)[0]); // this trailing space is for compatibility with the legacy Singular 704 Print("// minpoly : (%s^2+1)\n", n_ParameterNames(r)[0]); 705 } -
libpolys/coeffs/gnumpc.h
rce1f78 r7fee876 8 8 * ABSTRACT: computations with GMP floating-point numbers 9 9 */ 10 #include < coeffs/coeffs.h>10 #include <misc/auxiliary.h> 11 11 12 /// Get a mapping function from src into the domain of this type: long_C! 13 nMapFunc ngcSetMap(const coeffs src, const coeffs dst);12 struct n_Procs_s; 13 typedef struct n_Procs_s *coeffs; 14 14 15 /// Initialize r 15 /// Initialize r (n_long_C) 16 16 BOOLEAN ngcInitChar(coeffs r, void*); 17 17 18 void ngcSetChar(const coeffs r);19 20 // Private interface should be hidden!!!21 22 /// Note: MAY NOT WORK AS EXPECTED!23 BOOLEAN ngcGreaterZero(number za, const coeffs r);24 BOOLEAN ngcGreater(number a, number b, const coeffs r);25 BOOLEAN ngcEqual(number a, number b, const coeffs r);26 BOOLEAN ngcIsOne(number a, const coeffs r);27 BOOLEAN ngcIsMOne(number a, const coeffs r);28 BOOLEAN ngcIsZero(number za, const coeffs r);29 number ngcInit(long i, const coeffs r);30 int ngcInt(number &n, const coeffs r);31 number ngcNeg(number za, const coeffs r);32 number ngcInvers(number a, const coeffs r);33 number ngcPar(int i, const coeffs r);34 number ngcAdd(number la, number li, const coeffs r);35 number ngcSub(number la, number li, const coeffs r);36 number ngcMult(number a, number b, const coeffs r);37 number ngcDiv(number a, number b, const coeffs r);38 void ngcPower(number x, int exp, number *lu, const coeffs r);39 number ngcCopy(number a, const coeffs r);40 number ngc_Copy(number a, coeffs r);41 const char * ngcRead (const char *s, number *a, const coeffs r);42 void ngcWrite(number &a, const coeffs r);43 number ngcRePart(number a, const coeffs r);44 number ngcImPart(number a, const coeffs r);45 46 void ngcDelete(number *a, const coeffs r);47 void ngcCoeffWrite(const coeffs r, BOOLEAN details);48 49 #ifdef LDEBUG50 BOOLEAN ngcDBTest(number a, const char *f, const int l, const coeffs r);51 #endif52 53 54 number ngcMapQ(number from, const coeffs r, const coeffs aRing);55 18 #endif 56 19 /* GMPCOMPLEX_H */ -
libpolys/coeffs/gnumpfl.cc
rce1f78 r7fee876 454 454 assume( n->float_len <= n->float_len2 ); 455 455 assume( n->float_len2 >= SHORT_REAL_LENGTH ); 456 assume( n->complex_parameter == NULL ); 456 457 assume( n_NumberOfParameters(n) == 0 ); 458 assume( n_ParameterNames(n) == NULL ); 457 459 458 460 return FALSE; -
libpolys/coeffs/mpr_complex.cc
rce1f78 r7fee876 708 708 char *complexToStr( gmp_complex & c, const unsigned int oprec, const coeffs src ) 709 709 { 710 assume( src->complex_parameter != NULL ); 710 const char * complex_parameter = "I"; 711 int N = 1; // strlen(complex_parameter); 712 713 if (nCoeff_is_long_C(src)) 714 { 715 complex_parameter = n_ParameterNames(src)[0]; 716 N = strlen(complex_parameter); 717 } 718 719 assume( complex_parameter != NULL && N > 0); 711 720 712 721 char *out,*in_imag,*in_real; … … 721 730 if (nCoeff_is_long_C(src)) 722 731 { 723 int len=(strlen(in_real)+strlen(in_imag)+7+ strlen(src->complex_parameter))*sizeof(char);732 int len=(strlen(in_real)+strlen(in_imag)+7+N)*sizeof(char); 724 733 out=(char*)omAlloc(len); 725 734 memset(out,0,len); 726 735 if ( !c.real().isZero() ) // (-23-i*5.43) or (15.1+i*5.3) 727 sprintf(out,"(%s%s%s*%s)",in_real,c.imag().sign()>=0?"+":"-", src->complex_parameter,in_imag);736 sprintf(out,"(%s%s%s*%s)",in_real,c.imag().sign()>=0?"+":"-",complex_parameter,in_imag); 728 737 else // (-i*43) or (i*34) 729 738 { 730 739 if (c.imag().isOne()) 731 sprintf(out,"%s", src->complex_parameter);740 sprintf(out,"%s", complex_parameter); 732 741 else if (c.imag().isMOne()) 733 sprintf(out,"-%s", src->complex_parameter);742 sprintf(out,"-%s", complex_parameter); 734 743 else 735 sprintf(out,"(%s%s*%s)",c.imag().sign()>=0?"":"-", src->complex_parameter,in_imag);744 sprintf(out,"(%s%s*%s)",c.imag().sign()>=0?"":"-", complex_parameter,in_imag); 736 745 } 737 746 } -
libpolys/coeffs/numbers.cc
rce1f78 r7fee876 92 92 } 93 93 94 static number ndParameter(const int i, const coeffs r) 95 { 96 Werror("ndParameter: n_Parameter is not implemented/relevant for (coeff_type = %d)",getCoeffType(r)); 97 return NULL; 98 } 94 99 95 100 BOOLEAN n_IsZeroDivisor( number a, const coeffs r) … … 258 263 n->cfFarey = ndFarey; 259 264 n->cfParDeg = ndParDeg; 265 266 n->cfParameter = ndParameter; 260 267 261 268 #ifdef HAVE_RINGS … … 323 330 assume(n->cfWriteShort!=NULL); 324 331 332 assume(n->iNumberOfParameters>= 0); 333 334 assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) || 335 (n->iNumberOfParameters > 0 && n->pParameterNames != NULL) ); 336 337 assume(n->cfParameter!=NULL); 338 assume(n->cfParDeg!=NULL); 325 339 326 340 if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t); -
libpolys/coeffs/test.cc
rce1f78 r7fee876 77 77 PrintS("two: "); PrintSized(two, r); 78 78 79 if ( getCoeffType(r) == n_GF) //some special test for GF80 { 81 number z = n fPar (0, r); // also any integer instead of 0//?82 83 PrintS(" Generator: "); PrintSized(z, r);79 if (n_NumberOfParameters(r) > 0) 80 { 81 number z = n_Param(1, r); // also any integer instead of 0//? 82 83 PrintS("Parameter: "); PrintSized(z, r); 84 84 85 85 n_Delete(&z, r); … … 214 214 else if( type == n_long_C ) 215 215 { 216 assume( r->cfInit == ngcInit );217 assume( r->cfAdd == ngcAdd );218 assume( r->cfDelete == ngcDelete );216 // assume( r->cfInit == ngcInit ); 217 // assume( r->cfAdd == ngcAdd ); 218 // assume( r->cfDelete == ngcDelete ); 219 219 } 220 220 else if( type == n_R ) … … 240 240 else if( type == n_GF ) 241 241 { 242 assume( r->cfInit == nfInit );243 assume( r->cfAdd == nfAdd );242 // assume( r->cfInit == nfInit ); 243 // assume( r->cfAdd == nfAdd ); 244 244 //assume( r->cfDelete == nfDelete ); 245 245 } -
libpolys/polys/OBSOLETE_pInitContent.cc
rce1f78 r7fee876 797 797 { 798 798 number c=pGetCoeff(qq); 799 number ee=n fPar(1);799 number ee=n_Parameter(1, currRing->cf); // ? 800 800 number eee;nfPower(ee,e,&eee); //nfDelete(ee,currRing); 801 801 ee=nfMult(c,eee); -
libpolys/polys/ext_fields/algext.cc
rce1f78 r7fee876 788 788 } 789 789 790 /// return the specified parameter as a number in the given alg. field 791 static number naParameter(const int iParameter, const coeffs cf) 792 { 793 assume(getCoeffType(cf) == ID); 794 795 const ring R = cf->extRing; 796 assume( R != NULL ); 797 assume( 0 < iParameter && iParameter <= rVar(R) ); 798 799 poly p = p_One(R); p_SetExp(p, iParameter, 1, R); p_Setm(p, R); 800 801 return (number) p; 802 } 803 804 805 /// if m == var(i)/1 => return i, 806 int naIsParam(number m, const coeffs cf) 807 { 808 assume(getCoeffType(cf) == ID); 809 810 const ring R = cf->extRing; 811 assume( R != NULL ); 812 813 return p_Var( (poly)m, R ); 814 } 815 790 816 BOOLEAN naInitChar(coeffs cf, void * infoStruct) 791 817 { … … 805 831 assume( cf != NULL ); 806 832 assume(getCoeffType(cf) == ID); // coeff type; 807 808 cf->extRing = e->r; 809 cf->extRing->ref ++; // increase the ref.counter for the ground poly. ring! 810 811 cf->extRing->minideal = e->i; // make a copy? 833 834 ring R = e->r; 835 assume(R != NULL); 836 837 R->ref ++; // increase the ref.counter for the ground poly. ring! 838 839 R->minideal = e->i; // make a copy? 840 841 cf->extRing = R; 812 842 813 843 /* propagate characteristic up so that it becomes 814 844 directly accessible in cf: */ 815 cf->ch = cf->extRing->cf->ch;816 845 cf->ch = R->cf->ch; 846 817 847 #ifdef LDEBUG 818 848 p_Test((poly)naMinpoly, naRing); … … 868 898 cf->cfParDeg = naParDeg; 869 899 900 cf->iNumberOfParameters = rVar(R); 901 cf->pParameterNames = R->names; 902 cf->cfParameter = naParameter; 903 870 904 return FALSE; 871 905 } 872 873 874 number naParam(const short iParameter, const coeffs cf)875 {876 assume(getCoeffType(cf) == ID);877 878 const ring R = cf->extRing;879 assume( R != NULL );880 assume( 0 < iParameter && iParameter <= rVar(R) );881 882 poly p = p_One(R); p_SetExp(p, iParameter, 1, R); p_Setm(p, R);883 884 return (number) p;885 }886 887 888 /// if m == var(i)/1 => return i,889 int naIsParam(number m, const coeffs cf)890 {891 assume(getCoeffType(cf) == ID);892 893 const ring R = cf->extRing;894 assume( R != NULL );895 896 return p_Var( (poly)m, R );897 } -
libpolys/polys/ext_fields/algext.h
rce1f78 r7fee876 46 46 BOOLEAN naInitChar(coeffs cf, void* infoStruct); 47 47 48 /* Private hidden interface49 BOOLEAN naGreaterZero(number a, const coeffs cf);50 BOOLEAN naGreater(number a, number b, const coeffs cf);51 BOOLEAN naEqual(number a, number b, const coeffs cf);52 BOOLEAN naIsOne(number a, const coeffs cf);53 BOOLEAN naIsMOne(number a, const coeffs cf);54 BOOLEAN naIsZero(number a, const coeffs cf);55 number naInit(long i, const coeffs cf);56 int naInt(number &a, const coeffs cf);57 number naNeg(number a, const coeffs cf);58 number naInvers(number a, const coeffs cf);59 number naAdd(number a, number b, const coeffs cf);60 number naSub(number a, number b, const coeffs cf);61 number naMult(number a, number b, const coeffs cf);62 number naDiv(number a, number b, const coeffs cf);63 void naPower(number a, int exp, number *b, const coeffs cf);64 number naCopy(number a, const coeffs cf);65 void naWrite(number &a, const coeffs cf);66 number naRePart(number a, const coeffs cf);67 number naImPart(number a, const coeffs cf);68 number naGetDenom(number &a, const coeffs cf);69 number naGetNumerator(number &a, const coeffs cf);70 number naGcd(number a, number b, const coeffs cf);71 number naLcm(number a, number b, const coeffs cf);72 number naSize(number a, const coeffs cf);73 void naDelete(number * a, const coeffs cf);74 void naCoeffWrite(const coeffs cf);75 number naIntDiv(number a, number b, const coeffs cf);76 const char * naRead(const char *s, number *a, const coeffs cf);77 static BOOLEAN naCoeffIsEqual(const coeffs cf, n_coeffType n, void * param);78 */79 80 /// return the specified parameter as a number in the given alg. field81 number naParam(short iParameter, const coeffs cf);82 83 84 48 /// if m == var(i)/1 => return i, 85 49 int naIsParam(number, const coeffs); -
libpolys/polys/ext_fields/transext.cc
rce1f78 r7fee876 1357 1357 } 1358 1358 1359 /// return the specified parameter as a number in the given trans.ext. 1360 static number ntParameter(const int iParameter, const coeffs cf) 1361 { 1362 assume(getCoeffType(cf) == ID); 1363 1364 const ring R = cf->extRing; 1365 assume( R != NULL ); 1366 assume( 0 < iParameter && iParameter <= rVar(R) ); 1367 1368 poly p = p_One(R); p_SetExp(p, iParameter, 1, R); p_Setm(p, R); 1369 1370 // return (number) p; 1371 1372 fraction f = (fraction)omAlloc0Bin(fractionObjectBin); 1373 NUM(f) = p; 1374 DEN(f) = NULL; 1375 COM(f) = 0; 1376 1377 return (number)f; 1378 } 1379 1380 /// if m == var(i)/1 => return i, 1381 int ntIsParam(number m, const coeffs cf) 1382 { 1383 assume(getCoeffType(cf) == ID); 1384 1385 const ring R = cf->extRing; 1386 assume( R != NULL ); 1387 1388 fraction f = (fraction)m; 1389 1390 if( DEN(f) != NULL ) 1391 return 0; 1392 1393 return p_Var( NUM(f), R ); 1394 } 1395 1359 1396 BOOLEAN ntInitChar(coeffs cf, void * infoStruct) 1360 1397 { … … 1371 1408 assume(getCoeffType(cf) == ID); // coeff type; 1372 1409 1373 cf->extRing = e->r; 1374 cf->extRing->ref ++; // increase the ref.counter for the ground poly. ring! 1375 cf->factoryVarOffset = cf->extRing->cf->factoryVarOffset+rVar(cf->extRing); 1376 1410 ring R = e->r; 1411 assume(R != NULL); 1412 1413 R->ref ++; // increase the ref.counter for the ground poly. ring! 1414 1415 cf->extRing = R; 1377 1416 /* propagate characteristic up so that it becomes 1378 1417 directly accessible in cf: */ 1379 cf->ch = cf->extRing->cf->ch; 1380 1418 cf->ch = R->cf->ch; 1419 cf->factoryVarOffset = R->cf->factoryVarOffset + rVar(R); 1420 1381 1421 cf->cfGreaterZero = ntGreaterZero; 1382 1422 cf->cfGreater = ntGreater; … … 1432 1472 cf->cfParDeg = ntParDeg; 1433 1473 1474 cf->iNumberOfParameters = rVar(R); 1475 cf->pParameterNames = R->names; 1476 cf->cfParameter = ntParameter; 1477 1478 1434 1479 return FALSE; 1435 1480 } 1436 1437 1438 number ntParam(const short iParameter, const coeffs cf)1439 {1440 assume(getCoeffType(cf) == ID);1441 1442 const ring R = cf->extRing;1443 assume( R != NULL );1444 assume( 0 < iParameter && iParameter <= rVar(R) );1445 1446 poly p = p_One(R); p_SetExp(p, iParameter, 1, R); p_Setm(p, R);1447 1448 // return (number) p;1449 1450 fraction f = (fraction)omAlloc0Bin(fractionObjectBin);1451 NUM(f) = p;1452 DEN(f) = NULL;1453 COM(f) = 0;1454 1455 return (number)f;1456 }1457 1458 1459 /// if m == var(i)/1 => return i,1460 int ntIsParam(number m, const coeffs cf)1461 {1462 assume(getCoeffType(cf) == ID);1463 1464 const ring R = cf->extRing;1465 assume( R != NULL );1466 1467 fraction f = (fraction)m;1468 1469 if( DEN(f) != NULL )1470 return 0;1471 1472 return p_Var( NUM(f), R );1473 } -
libpolys/polys/ext_fields/transext.h
rce1f78 r7fee876 130 130 */ 131 131 132 /// return the specified parameter as a number in the given trans.ext.133 number ntParam(short iParameter, const coeffs cf);134 135 132 /// if m == var(i)/1 => return i, 136 133 int ntIsParam(number, const coeffs); -
libpolys/polys/monomials/maps.cc
rce1f78 r7fee876 157 157 } 158 158 159 void maFindPerm(char **preim_names, int preim_n, char **preim_par, int preim_p,160 char **names, int n, char **par, int nop,159 void maFindPerm(char const * const * const preim_names, int preim_n, char const * const * const preim_par, int preim_p, 160 char const * const * const names, int n, char const * const * const par, int nop, 161 161 int * perm, int *par_perm, n_coeffType ch) 162 162 { -
libpolys/polys/monomials/maps.h
rce1f78 r7fee876 23 23 poly maIMap(ring src_ring, ring dst_ring, poly p); 24 24 25 void maFindPerm(char **preim_names, int preim_n, char **preim_par, int preim_p,26 char **names, int n, char **par, int nop,25 void maFindPerm(char const * const * const preim_names, int preim_n, char const * const * const preim_par, int preim_p, 26 char const * const * const names, int n, char const * const * const par, int nop, 27 27 int * perm, int *par_perm, n_coeffType ch); 28 28 poly pSubstPoly(poly p, int var, poly image); -
libpolys/polys/monomials/p_polys.cc
rce1f78 r7fee876 3520 3520 if (rField_is_GF(dst)) 3521 3521 { 3522 3523 number ee = n fPar(1, dst->cf); // NOTE: using nfPar is a BAD thing to do...3522 assume( dst->cf->extRing == NULL ); 3523 number ee = n_Param(1, dst); 3524 3524 3525 3525 number eee; -
libpolys/polys/monomials/ring.cc
rce1f78 r7fee876 276 276 { 277 277 PrintS("// characteristic : "); 278 if (rParameter(r)!=NULL) 278 279 char const * const * const params = rParameter(r); 280 281 if (params!=NULL) 279 282 { 280 283 Print ("// %d parameter : ",rPar(r)); 281 char **sp= rParameter(r); 284 285 char const * const * sp= params; 282 286 int nop=0; 283 287 while (nop<rPar(r)) … … 291 295 { 292 296 // i^2+1: 293 Print("(%s^2+1)\n", rParameter(r)[0]);297 Print("(%s^2+1)\n", params[0]); 294 298 } 295 299 else if (rMinpolyIsNULL(r)) … … 666 670 return omStrDup("real"); /* short real */ 667 671 } 668 char **params = rParameter(r);672 char const * const * const params = rParameter(r); 669 673 if (params==NULL) 670 674 { … … 690 694 for(i=0; i<rPar(r);i++) 691 695 { 692 l+=(strlen( rParameter(r)[i])+1);696 l+=(strlen(params[i])+1); 693 697 } 694 698 s=(char *)omAlloc((long)(l+MAX_INT_LEN+1)); … … 701 705 { 702 706 strcat(s,tt); 703 strcat(s, rParameter(r)[i]);707 strcat(s,params[i]); 704 708 } 705 709 return s; … … 709 713 { 710 714 if ((r==NULL)||(rParameter(r)==NULL)) return omStrDup(""); 715 716 char const * const * const params = rParameter(r); 711 717 712 718 int i; … … 715 721 for (i=0; i<rPar(r); i++) 716 722 { 717 l+=strlen( rParameter(r)[i])+1;723 l+=strlen(params[i])+1; 718 724 } 719 725 char *s=(char *)omAlloc((long)l); … … 721 727 for (i=0; i<rPar(r)-1; i++) 722 728 { 723 strcat(s, rParameter(r)[i]);729 strcat(s, params[i]); 724 730 strcat(s,","); 725 731 } 726 strcat(s, rParameter(r)[i]);732 strcat(s, params[i]); 727 733 return s; 728 734 } … … 5634 5640 5635 5641 5636 5637 number n_Param(const short iParameter, const ring r)5642 /// TODO: rewrite somehow... 5643 int n_IsParam(const number m, const ring r) 5638 5644 { 5639 5645 assume(r != NULL); … … 5641 5647 assume(C != NULL); 5642 5648 5643 const n_coeffType _filed_type = getCoeffType(C); 5644 5645 if ( iParameter <= 0 || iParameter > rPar(r) ) 5646 // Wrong parameter 5647 return NULL; 5648 5649 if( _filed_type == n_algExt ) 5650 return naParam(iParameter, C); 5651 5652 if( _filed_type == n_transExt ) 5653 return ntParam(iParameter, C); 5654 5655 return NULL; 5656 } 5657 5658 5659 5660 int n_IsParam(number m, const ring r) 5661 { 5662 assume(r != NULL); 5663 const coeffs C = r->cf; 5664 assume(C != NULL); 5649 assume( nCoeff_is_Extension(C) ); 5665 5650 5666 5651 const n_coeffType _filed_type = getCoeffType(C); … … 5672 5657 return ntIsParam(m, C); 5673 5658 5659 Werror("n_IsParam: IsParam is not to be used for (coeff_type = %d)",getCoeffType(C)); 5660 5674 5661 return 0; 5675 5662 } -
libpolys/polys/monomials/ring.h
rce1f78 r7fee876 538 538 539 539 /// (r->cf->P) 540 static inline short rPar(const ring r)540 static inline int rPar(const ring r) 541 541 { 542 542 assume(r != NULL); … … 544 544 assume(C != NULL); 545 545 546 if( rField_is_Extension(r) ) 547 { 548 const ring R = C->extRing; 549 assume( R != NULL ); 550 return rVar( R ); 551 } 552 else if (nCoeff_is_long_C(C)) 553 { 554 return 1; 555 } 556 return 0; 546 return n_NumberOfParameters(C); 547 // if( nCoeff_is_Extension(C) ) 548 // { 549 // const ring R = C->extRing; 550 // assume( R != NULL ); 551 // return rVar( R ); 552 // } 553 // else if (nCoeff_is_GF(C)) 554 // { 555 // return 1; 556 // } 557 // else if (nCoeff_is_long_C(C)) 558 // { 559 // return 1; 560 // } 561 // return 0; 557 562 } 558 563 559 564 560 565 /// (r->cf->parameter) 561 static inline char ** rParameter(const ring r)566 static inline char const * const * rParameter(const ring r) 562 567 { 563 568 assume(r != NULL); … … 565 570 assume(C != NULL); 566 571 567 if( rField_is_Extension(r) ) // only alg / trans. exts... 568 { 569 const ring R = C->extRing; 570 assume( R != NULL ); 571 return R->names; 572 } 573 else if (nCoeff_is_GF(C)) 574 { 575 return &(C->m_nfParameter); 576 } 577 else if (nCoeff_is_long_C(C)) 578 { 579 return &(C->complex_parameter); 580 } 581 return NULL; 572 return n_ParameterNames(C); 573 // if( nCoeff_is_Extension(C) ) // only alg / trans. exts... 574 // { 575 // const ring R = C->extRing; 576 // assume( R != NULL ); 577 // return R->names; 578 // } 579 // else if (nCoeff_is_GF(C)) 580 // { 581 // return &(C->m_nfParameter); 582 // } 583 // else if (nCoeff_is_long_C(C)) 584 // { 585 // return &(C->complex_parameter); 586 // } 587 // return NULL; 582 588 } 583 589 … … 585 591 /// polynomial ring, or NULL if invalid 586 592 /// parameters (as variables) begin with 1! 587 number n_Param(const short iParameter, const ring r); 593 static inline number n_Param(const short iParameter, const ring r) 594 { 595 assume(r != NULL); 596 const coeffs C = r->cf; 597 assume(C != NULL); 598 return n_Param(iParameter, C); 599 // const n_coeffType _filed_type = getCoeffType(C); 600 // 601 // if ( iParameter <= 0 || iParameter > rPar(r) ) 602 // // Wrong parameter 603 // return NULL; 604 // 605 // if( _filed_type == n_algExt ) 606 // return naParameter(iParameter, C); 607 // 608 // if( _filed_type == n_transExt ) 609 // return ntParameter(iParameter, C); 610 // 611 // if (_filed_type == n_GF)// if (nCoeff_is_GF(C)) 612 // { 613 // number nfPar (int i, const coeffs); 614 // return nfPar(iParameter, C); 615 // } 616 // 617 // if (_filed_type == n_long_C) // if (nCoeff_is_long_C(C)) 618 // { 619 // number ngcPar(int i, const coeffs r); 620 // return ngcPar(iParameter, C); 621 // } 622 // 623 // return NULL; 624 } 588 625 589 626 /// if m == var(i)/1 => return i, … … 603 640 static inline BOOLEAN rIsExtension(const ring r) 604 641 { 642 assume(r != NULL); 643 const coeffs C = r->cf; 644 assume(C != NULL); 605 645 // assume( (rParameter(r)!=NULL) == rField_is_Extension(r) ); // ? 606 return rField_is_Extension(r) || nCoeff_is_GF(r->cf);646 return nCoeff_is_Extension(C) || nCoeff_is_GF(C) || nCoeff_is_long_C(C); 607 647 } 608 648 -
libpolys/tests/coeffs_test.h
rce1f78 r7fee876 234 234 } 235 235 236 237 if (getCoeffType(r) == n_GF) //some special test for GF 238 { 239 number z = nfPar (0, r); // also any integer instead of 0//? 240 clog << "Generator: "; PrintSized(z, r); 241 n_Delete(&z, r); 236 if (n_NumberOfParameters(r) > 0) 237 { 238 number z = n_Param(1, r); // also any integer instead of 0//? 239 PrintS("Parameter: "); PrintSized(z, r); 240 n_Delete(&z, r); 242 241 } 242 243 243 244 244 clog << "Char: " << n_GetChar(r) << endl; … … 294 294 case n_long_C: 295 295 { 296 TS_ASSERT_EQUALS( r->cfInit, ngcInit );297 TS_ASSERT_EQUALS( r->cfAdd, ngcAdd );298 TS_ASSERT_EQUALS( r->cfDelete, ngcDelete );296 // TS_ASSERT_EQUALS( r->cfInit, ngcInit ); 297 // TS_ASSERT_EQUALS( r->cfAdd, ngcAdd ); 298 // TS_ASSERT_EQUALS( r->cfDelete, ngcDelete ); 299 299 break; 300 300 } … … 308 308 case n_GF: 309 309 { 310 TS_ASSERT_EQUALS( r->cfInit, nfInit );311 TS_ASSERT_EQUALS( r->cfAdd, nfAdd );310 // TS_ASSERT_EQUALS( r->cfInit, nfInit ); 311 // TS_ASSERT_EQUALS( r->cfAdd, nfAdd ); 312 312 //TS_ASSERT_EQUALS( r->cfDelete, nfDelete ); 313 313 break;
Note: See TracChangeset
for help on using the changeset viewer.