My Project
Data Structures | Functions | Variables
numbers.cc File Reference
#include <string.h>
#include <stdlib.h>
#include "misc/auxiliary.h"
#include "misc/mylimits.h"
#include "factory/factory.h"
#include "reporter/reporter.h"
#include "coeffs/coeffs.h"
#include "coeffs/numbers.h"
#include "coeffs/longrat.h"
#include "coeffs/modulop.h"
#include "coeffs/gnumpfl.h"
#include "coeffs/gnumpc.h"
#include "coeffs/ffields.h"
#include "coeffs/shortfl.h"
#include "coeffs/ntupel.h"
#include "coeffs/flintcf_Qrat.h"
#include "coeffs/rmodulo2m.h"
#include "coeffs/rmodulon.h"
#include "coeffs/rintegers.h"
#include "polys/ext_fields/algext.h"
#include "polys/ext_fields/transext.h"

Go to the source code of this file.

Data Structures

struct  nFindCoeffByName_p
 

Functions

void nNew (number *d)
 
static void ndDelete (number *d, const coeffs)
 
static number ndAnn (number, const coeffs)
 
static char * ndCoeffString (const coeffs r)
 
static void ndCoeffWrite (const coeffs r, BOOLEAN)
 
static char * ndCoeffName (const coeffs r)
 
static void ndInpMult (number &a, number b, const coeffs r)
 
static void ndInpAdd (number &a, number b, const coeffs r)
 
static void ndPower (number a, int i, number *res, const coeffs r)
 
static number ndInvers (number a, const coeffs r)
 
static BOOLEAN ndIsUnit_Ring (number a, const coeffs r)
 
static BOOLEAN ndIsUnit_Field (number a, const coeffs r)
 
static number ndGetUnit_Ring (number, const coeffs r)
 
static BOOLEAN ndDBTest (number, const char *, const int, const coeffs)
 
static number ndFarey (number, number, const coeffs r)
 
static number ndChineseRemainder (number *, number *, int, BOOLEAN, CFArray &, const coeffs r)
 
static int ndParDeg (number n, const coeffs r)
 
static number ndParameter (const int, const coeffs r)
 
BOOLEAN n_IsZeroDivisor (number a, const coeffs r)
 Test whether a is a zero divisor in r i.e. not coprime with char. of r very inefficient implementation: should ONLY be used for debug stuff /tests. More...
 
void ndNormalize (number &, const coeffs)
 
static number ndReturn0 (number, const coeffs r)
 
number ndGcd (number, number, const coeffs r)
 
static number ndIntMod (number, number, const coeffs r)
 
static number ndGetDenom (number &, const coeffs r)
 
static number ndGetNumerator (number &a, const coeffs r)
 
static int ndSize (number a, const coeffs r)
 
static void ndClearContent (ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
 
static void ndClearDenominators (ICoeffsEnumerator &, number &d, const coeffs r)
 
static number ndCopy (number a, const coeffs)
 
number ndCopyMap (number a, const coeffs aRing, const coeffs r)
 
static void ndKillChar (coeffs)
 
static void ndSetChar (const coeffs)
 
number nd_Copy (number a, const coeffs r)
 
static BOOLEAN ndDivBy (number, number, const coeffs)
 
static int ndDivComp (number, number, const coeffs)
 
static number ndExtGcd (number, number, number *, number *, const coeffs r)
 
CanonicalForm ndConvSingNFactoryN (number, BOOLEAN, const coeffs)
 
static number ndConvFactoryNSingN (const CanonicalForm, const coeffs)
 [in, out] a bigint number >= 0
More...
 
static void ndMPZ (mpz_t result, number &n, const coeffs r)
 Converts a non-negative bigint number into a GMP number. More...
 
static number ndInitMPZ (mpz_t m, const coeffs r)
 
static BOOLEAN ndCoeffIsEqual (const coeffs r, n_coeffType n, void *)
 
static number ndQuotRem (number a, number b, number *r, const coeffs R)
 
coeffs nInitChar (n_coeffType t, void *parameter)
 one-time initialisations for new coeffs in case of an error return NULL More...
 
void nKillChar (coeffs r)
 undo all initialisations More...
 
n_coeffType nRegister (n_coeffType n, cfInitCharProc p)
 
void nRegisterCfByName (cfInitCfByNameProc p, n_coeffType n)
 
coeffs nFindCoeffByName (char *cf_name)
 find an existing coeff by its "CoeffName" More...
 
void n_Print (number &a, const coeffs r)
 print a number (BEWARE of string buffers!) mostly for debugging More...
 
char * nEati (char *s, int *i, int m)
 divide by the first (leading) number and return it, i.e. make monic More...
 
char * nEatLong (char *s, mpz_ptr i)
 extracts a long integer from s, returns the rest More...
 

Variables

VAR n_Procs_scf_root =NULL
 
STATIC_VAR n_coeffType nLastCoeffs =n_CF
 
VAR cfInitCharProc nInitCharTableDefault []
 
STATIC_VAR cfInitCharProcnInitCharTable =nInitCharTableDefault
 
VAR nFindCoeffByName_p nFindCoeffByName_Root =NULL
 

Data Structure Documentation

◆ nFindCoeffByName_s

struct nFindCoeffByName_s

Definition at line 582 of file numbers.cc.

Data Fields
n_coeffType n
nFindCoeffByName_p next
cfInitCfByNameProc p

Function Documentation

◆ n_IsZeroDivisor()

BOOLEAN n_IsZeroDivisor ( number  a,
const coeffs  r 
)

Test whether a is a zero divisor in r i.e. not coprime with char. of r very inefficient implementation: should ONLY be used for debug stuff /tests.

Definition at line 149 of file numbers.cc.

150 {
151  BOOLEAN ret = n_IsZero(a, r);
152  int c = n_GetChar(r);
153  if (ret || (c==0) || (r->is_field))
154  return ret; /*n_IsZero(a, r)*/
155  number ch = n_Init( c, r );
156  number g = n_Gcd( ch, a, r );
157  ret = !n_IsOne (g, r);
158  n_Delete(&ch, r);
159  n_Delete(&g, r);
160  return ret;
161 }
int BOOLEAN
Definition: auxiliary.h:87
g
Definition: cfModGcd.cc:4090
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ,...
Definition: coeffs.h:664
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:464
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:538
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:468

◆ n_Print()

void n_Print ( number &  a,
const coeffs  r 
)

print a number (BEWARE of string buffers!) mostly for debugging

Definition at line 621 of file numbers.cc.

623 {
624  assume(r != NULL);
625  n_Test(a,r);
626 
627  StringSetS("");
628  n_Write(a, r);
629  { char* s = StringEndS(); Print("%s", s); omFree(s); }
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:712
static FORCE_INLINE void n_Write(number n, const coeffs r, const BOOLEAN bShortOut=TRUE)
Definition: coeffs.h:591
#define Print
Definition: emacs.cc:80
const CanonicalForm int s
Definition: facAbsFact.cc:51
#define assume(x)
Definition: mod2.h:387
#define omFree(addr)
Definition: omAllocDecl.h:261
#define NULL
Definition: omList.c:12
void StringSetS(const char *st)
Definition: reporter.cc:128
char * StringEndS()
Definition: reporter.cc:151

◆ nd_Copy()

number nd_Copy ( number  a,
const coeffs  r 
)

Definition at line 268 of file numbers.cc.

268 { return r->cfCopy(a, r); }

◆ ndAnn()

static number ndAnn ( number  ,
const  coeffs 
)
static

Definition at line 51 of file numbers.cc.

51 { return NULL;}

◆ ndChineseRemainder()

static number ndChineseRemainder ( number *  ,
number *  ,
int  ,
BOOLEAN  ,
CFArray ,
const coeffs  r 
)
static

Definition at line 133 of file numbers.cc.

134 {
135  Werror("ChineseRemainder not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
136  return r->cfInit(0,r);
137 }
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ ndClearContent()

static void ndClearContent ( ICoeffsEnumerator numberCollectionEnumerator,
number &  c,
const coeffs  r 
)
static

TODO: move to a separate implementation

Definition at line 171 of file numbers.cc.

172 {
173  assume(r != NULL);
174 
175  // no fractions
176  assume(!( nCoeff_is_Q(r) ));
177  // all coeffs are given by integers!!!
178 
179  numberCollectionEnumerator.Reset();
180 
181  if( !numberCollectionEnumerator.MoveNext() ) // empty zero polynomial?
182  {
183  c = n_Init(1, r);
184  return;
185  }
186 
187  number &curr = numberCollectionEnumerator.Current();
188 
189 #ifdef HAVE_RINGS
190  /// TODO: move to a separate implementation
191  if (nCoeff_is_Ring(r))
192  {
193  if (nCoeff_has_Units(r))
194  {
195  c = n_GetUnit(curr, r);
196 
197  if (!n_IsOne(c, r))
198  {
199  number inv = n_Invers(c, r);
200 
201  n_InpMult(curr, inv, r);
202 
203  while( numberCollectionEnumerator.MoveNext() )
204  {
205  number &n = numberCollectionEnumerator.Current();
206  n_Normalize(n, r); // ?
207  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
208  }
209 
210  n_Delete(&inv, r);
211  }
212  } else c = n_Init(1, r);
213 
214  return;
215  }
216 #endif
217 
218  assume(!nCoeff_is_Ring(r));
220 
221  n_Normalize(curr, r); // Q: good/bad/ugly??
222 
223  if (!n_IsOne(curr, r))
224  {
225  number t = curr; // takes over the curr! note: not a reference!!!
226 
227  curr = n_Init(1, r); // ???
228 
229  number inv = n_Invers(t, r);
230 
231  while( numberCollectionEnumerator.MoveNext() )
232  {
233  number &n = numberCollectionEnumerator.Current();
234  n_InpMult(n, inv, r); // TODO: either this or directly divide!!!?
235 // n_Normalize(n, r); // ?
236  }
237 
238  n_Delete(&inv, r);
239 
240  c = t;
241  } else
242  c = n_Copy(curr, r); // c == 1 and nothing else to do...
243 }
virtual reference Current()=0
Gets the current element in the collection (read and write).
virtual void Reset()=0
Sets the enumerator to its initial position: -1, which is before the first element in the collection.
virtual bool MoveNext()=0
Advances the enumerator to the next element of the collection. returns true if the enumerator was suc...
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:451
static FORCE_INLINE BOOLEAN nCoeff_has_Units(const coeffs r)
returns TRUE, if r is not a field and r has non-trivial units
Definition: coeffs.h:797
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:839
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible
Definition: coeffs.h:564
static FORCE_INLINE BOOLEAN nCoeff_is_numeric(const coeffs r)
Definition: coeffs.h:832
static FORCE_INLINE BOOLEAN nCoeff_is_Zp_a(const coeffs r)
Definition: coeffs.h:859
static FORCE_INLINE BOOLEAN nCoeff_is_Q_algext(const coeffs r)
is it an alg. ext. of Q?
Definition: coeffs.h:914
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:806
static FORCE_INLINE number n_GetUnit(number n, const coeffs r)
in Z: 1 in Z/kZ (where k is not a prime): largest divisor of n (taken in Z) that is co-prime with k i...
Definition: coeffs.h:532
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:730
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:800
static FORCE_INLINE void n_InpMult(number &a, number b, const coeffs r)
multiplication of 'a' and 'b'; replacement of 'a' by the product a*b
Definition: coeffs.h:641
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:578

◆ ndClearDenominators()

static void ndClearDenominators ( ICoeffsEnumerator ,
number &  d,
const coeffs  r 
)
static

Definition at line 245 of file numbers.cc.

246 {
247  assume( r != NULL );
250 
251  d = n_Init(1, r);
252 }
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:910
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:918

◆ ndCoeffIsEqual()

static BOOLEAN ndCoeffIsEqual ( const coeffs  r,
n_coeffType  n,
void *   
)
static

Definition at line 302 of file numbers.cc.

304 {
305  /* test, if r is an instance of nInitCoeffs(n,parameter) */
306  /* if parameter is not needed */
307  return (n==r->type);

◆ ndCoeffName()

static char* ndCoeffName ( const coeffs  r)
static

Definition at line 60 of file numbers.cc.

61 {
62  STATIC_VAR char s[20];
63  snprintf(s,11,"Coeffs(%d)",r->type);
64  return s;
65 }
#define STATIC_VAR
Definition: globaldefs.h:7

◆ ndCoeffString()

static char* ndCoeffString ( const coeffs  r)
static

Definition at line 52 of file numbers.cc.

53 {
54  return omStrDup(r->cfCoeffName(r));
55 }
#define omStrDup(s)
Definition: omAllocDecl.h:263

◆ ndCoeffWrite()

static void ndCoeffWrite ( const coeffs  r,
BOOLEAN   
)
static

Definition at line 56 of file numbers.cc.

57 {
58  PrintS(r->cfCoeffName(r));
59 }
void PrintS(const char *s)
Definition: reporter.cc:284

◆ ndConvFactoryNSingN()

static number ndConvFactoryNSingN ( const  CanonicalForm,
const  coeffs 
)
static

[in, out] a bigint number >= 0

[out] the GMP equivalent

Definition at line 283 of file numbers.cc.

◆ ndConvSingNFactoryN()

CanonicalForm ndConvSingNFactoryN ( number  ,
BOOLEAN  ,
const  coeffs 
)

Definition at line 276 of file numbers.cc.

277 {
278  CanonicalForm term(0);
279  WerrorS("no conversion to factory");
280  return term;
281 }
factory's main class
Definition: canonicalform.h:86
Definition: int_poly.h:33
void WerrorS(const char *s)
Definition: feFopen.cc:24

◆ ndCopy()

static number ndCopy ( number  a,
const  coeffs 
)
static

Definition at line 254 of file numbers.cc.

254 { return a; }

◆ ndCopyMap()

number ndCopyMap ( number  a,
const coeffs  aRing,
const coeffs  r 
)

Definition at line 255 of file numbers.cc.

256 {
257  // aRing and r need not be the same, but must be the same representation
258  assume(aRing->rep==r->rep);
260  return a;
261  else
262  return r->cfCopy(a, r);
263 }
static FORCE_INLINE BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
TRUE if n_Delete/n_New are empty operations.
Definition: coeffs.h:906

◆ ndDBTest()

static BOOLEAN ndDBTest ( number  ,
const char *  ,
const int  ,
const  coeffs 
)
static

Definition at line 125 of file numbers.cc.

125 { return TRUE; }
#define TRUE
Definition: auxiliary.h:100

◆ ndDelete()

static void ndDelete ( number *  d,
const  coeffs 
)
static

Definition at line 50 of file numbers.cc.

50 { *d=NULL; }

◆ ndDivBy()

static BOOLEAN ndDivBy ( number  ,
number  ,
const  coeffs 
)
static

Definition at line 271 of file numbers.cc.

271 { return TRUE; } // assume a,b !=0

◆ ndDivComp()

static int ndDivComp ( number  ,
number  ,
const  coeffs 
)
static

Definition at line 272 of file numbers.cc.

272 { return 2; }

◆ ndExtGcd()

static number ndExtGcd ( number  ,
number  ,
number *  ,
number *  ,
const coeffs  r 
)
static

Definition at line 273 of file numbers.cc.

273 { return r->cfInit(1,r); }

◆ ndFarey()

static number ndFarey ( number  ,
number  ,
const coeffs  r 
)
static

Definition at line 128 of file numbers.cc.

129 {
130  Werror("farey not implemented for %s (c=%d)",r->cfCoeffName(r),getCoeffType(r));
131  return NULL;
132 }

◆ ndGcd()

number ndGcd ( number  a,
number  b,
const coeffs  r 
)

Definition at line 165 of file numbers.cc.

165 { return r->cfInit(1,r); }

◆ ndGetDenom()

static number ndGetDenom ( number &  ,
const coeffs  r 
)
static

Definition at line 167 of file numbers.cc.

167 { return r->cfInit(1,r); }

◆ ndGetNumerator()

static number ndGetNumerator ( number &  a,
const coeffs  r 
)
static

Definition at line 168 of file numbers.cc.

168 { return r->cfCopy(a,r); }

◆ ndGetUnit_Ring()

static number ndGetUnit_Ring ( number  ,
const coeffs  r 
)
static

Definition at line 121 of file numbers.cc.

122 { return r->cfInit(1,r); }

◆ ndInitMPZ()

static number ndInitMPZ ( mpz_t  m,
const coeffs  r 
)
static

Definition at line 296 of file numbers.cc.

298 {
299  return r->cfInit( mpz_get_si(m), r);
int m
Definition: cfEzgcd.cc:128

◆ ndInpAdd()

static void ndInpAdd ( number &  a,
number  b,
const coeffs  r 
)
static

Definition at line 72 of file numbers.cc.

73 {
74  number n=r->cfAdd(a,b,r);
75  r->cfDelete(&a,r);
76  a=n;
77 }
CanonicalForm b
Definition: cfModGcd.cc:4103

◆ ndInpMult()

static void ndInpMult ( number &  a,
number  b,
const coeffs  r 
)
static

Definition at line 66 of file numbers.cc.

67 {
68  number n=r->cfMult(a,b,r);
69  r->cfDelete(&a,r);
70  a=n;
71 }

◆ ndIntMod()

static number ndIntMod ( number  ,
number  ,
const coeffs  r 
)
static

Definition at line 166 of file numbers.cc.

166 { return r->cfInit(0,r); }

◆ ndInvers()

static number ndInvers ( number  a,
const coeffs  r 
)
static

Definition at line 109 of file numbers.cc.

110 {
111  number one=r->cfInit(1,r);
112  number res=r->cfDiv(one,a,r);
113  r->cfDelete(&one,r);
114  return res;
115 }
CanonicalForm res
Definition: facAbsFact.cc:60

◆ ndIsUnit_Field()

static BOOLEAN ndIsUnit_Field ( number  a,
const coeffs  r 
)
static

Definition at line 119 of file numbers.cc.

120 { return !r->cfIsZero(a,r); }

◆ ndIsUnit_Ring()

static BOOLEAN ndIsUnit_Ring ( number  a,
const coeffs  r 
)
static

Definition at line 117 of file numbers.cc.

118 { return r->cfIsOne(a,r)|| r->cfIsMOne(a,r); }

◆ ndKillChar()

static void ndKillChar ( coeffs  )
static

Definition at line 265 of file numbers.cc.

265 {}

◆ ndMPZ()

static void ndMPZ ( mpz_t  result,
number &  n,
const coeffs  r 
)
static

Converts a non-negative bigint number into a GMP number.

Definition at line 291 of file numbers.cc.

293 {
294  mpz_init_set_si( result, r->cfInt(n, r) );
return result
Definition: facAbsBiFact.cc:75

◆ ndNormalize()

void ndNormalize ( number &  ,
const  coeffs 
)

Definition at line 163 of file numbers.cc.

163 { }

◆ ndParameter()

static number ndParameter ( const int  ,
const coeffs  r 
)
static

Definition at line 144 of file numbers.cc.

145 {
146  return r->cfInit(1,r);
147 }

◆ ndParDeg()

static int ndParDeg ( number  n,
const coeffs  r 
)
static

Definition at line 139 of file numbers.cc.

140 {
141  return (-r->cfIsZero(n,r));
142 }

◆ ndPower()

static void ndPower ( number  a,
int  i,
number *  res,
const coeffs  r 
)
static

Definition at line 79 of file numbers.cc.

80 {
81  if (i==0)
82  {
83  *res = r->cfInit(1, r);
84  }
85  else if (i==1)
86  {
87  *res = r->cfCopy(a, r);
88  }
89  else if (i==2)
90  {
91  *res = r->cfMult(a, a, r);
92  }
93  else if (i<0)
94  {
95  number b = r->cfInvers(a, r);
96  ndPower(b, -i, res, r);
97  r->cfDelete(&b, r);
98  }
99  else
100  {
101  ndPower(a, i/2, res, r);
102  r->cfInpMult(*res, *res, r);
103  if (i&1)
104  {
105  r->cfInpMult(*res, a, r);
106  }
107  }
108 }
int i
Definition: cfEzgcd.cc:132
static void ndPower(number a, int i, number *res, const coeffs r)
Definition: numbers.cc:79

◆ ndQuotRem()

static number ndQuotRem ( number  a,
number  b,
number *  r,
const coeffs  R 
)
static

Definition at line 309 of file numbers.cc.

311 {
312  // implementation for a field: r: 0, result: n_Div
313  assume(R->is_field);
314  *r=n_Init(0,R);
315  return n_Div(a,b,R);
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition: coeffs.h:615
#define R
Definition: sirandom.c:27

◆ ndReturn0()

static number ndReturn0 ( number  ,
const coeffs  r 
)
static

Definition at line 164 of file numbers.cc.

164 { return r->cfInit(0,r); }

◆ ndSetChar()

static void ndSetChar ( const  coeffs)
static

Definition at line 266 of file numbers.cc.

266 {}

◆ ndSize()

static int ndSize ( number  a,
const coeffs  r 
)
static

Definition at line 169 of file numbers.cc.

169 { return (int)r->cfIsZero(a,r)==FALSE; }
#define FALSE
Definition: auxiliary.h:96

◆ nEati()

char* nEati ( char *  s,
int *  i,
int  m 
)

divide by the first (leading) number and return it, i.e. make monic

does nothing (just returns a dummy one number) helper routine: read an int from a string (mod m), return a pointer to the rest

Definition at line 631 of file numbers.cc.

633 {
634 
635  if (((*s) >= '0') && ((*s) <= '9'))
636  {
637  unsigned long ii=0L;
638  do
639  {
640  ii *= 10;
641  ii += *s++ - '0';
642  if ((m!=0) && (ii > (MAX_INT_VAL / 10))) ii = ii % m;
643  }
644  while (((*s) >= '0') && ((*s) <= '9'));
645  if ((m!=0) && (ii>=(unsigned)m)) ii=ii%m;
646  *i=(int)ii;
647  }
648  else (*i) = 1;
649  return s;
const int MAX_INT_VAL
Definition: mylimits.h:12

◆ nEatLong()

char* nEatLong ( char *  s,
mpz_ptr  i 
)

extracts a long integer from s, returns the rest

Definition at line 652 of file numbers.cc.

654 {
655  const char * start=s;
656 
657  while (*s >= '0' && *s <= '9') s++;
658  if (*s=='\0')
659  {
660  mpz_set_str(i,start,10);
661  }
662  else
663  {
664  char c=*s;
665  *s='\0';
666  mpz_set_str(i,start,10);
667  *s=c;
668  }
669  return s;

◆ nFindCoeffByName()

coeffs nFindCoeffByName ( char *  cf_name)

find an existing coeff by its "CoeffName"

Definition at line 599 of file numbers.cc.

601 {
602  n_Procs_s* n=cf_root;
603  // try existings coeffs:
604  while(n!=NULL)
605  {
606  if ((n->cfCoeffName!=NULL)
607  && (strcmp(cf_name,n->cfCoeffName(n))==0)) return n;
608  n=n->next;
609  }
610  // TODO: parametrized cf, e.g. flint:Z/26[a]
611  // try existing types:
612  nFindCoeffByName_p p=nFindCoeffByName_Root;
613  while(p!=NULL)
614  {
615  coeffs cf=p->p(cf_name,p->n);
616  if (cf!=NULL) return cf;
617  p=p->next;
618  }
619  return NULL;
int p
Definition: cfModGcd.cc:4078
CanonicalForm cf
Definition: cfModGcd.cc:4083
The main handler for Singular numbers which are suitable for Singular polynomials.
VAR nFindCoeffByName_p nFindCoeffByName_Root
Definition: numbers.cc:589
VAR n_Procs_s * cf_root
Definition: numbers.cc:45
char *(* cfCoeffName)(const coeffs r)
default name of cf, should substitue cfCoeffWrite, cfCoeffString
Definition: coeffs.h:154
coeffs next
Definition: coeffs.h:125

◆ nInitChar()

coeffs nInitChar ( n_coeffType  t,
void *  parameter 
)

one-time initialisations for new coeffs in case of an error return NULL

Definition at line 354 of file numbers.cc.

356 {
357  n_Procs_s *n=cf_root;
358 
359  while((n!=NULL) && (n->nCoeffIsEqual!=NULL) && (!n->nCoeffIsEqual(n,t,parameter)))
360  n=n->next;
361 
362  if (n==NULL)
363  {
364  n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
365  n->next=cf_root;
366  n->ref=1;
367  n->type=t;
368 
369  // default entries (different from NULL) for some routines:
371  n->cfSize = ndSize;
374  n->cfImPart=ndReturn0;
375  n->cfDelete= ndDelete;
376  n->cfAnn = ndAnn;
379  n->cfCoeffName = ndCoeffName; // should alway be changed!
380  n->cfInpMult=ndInpMult;
381  n->cfInpAdd=ndInpAdd;
382  n->cfCopy = ndCopy;
383  n->cfIntMod=ndIntMod; /* dummy !! */
385  n->cfGcd = ndGcd;
386  n->cfNormalizeHelper = ndGcd; /* tricky, isn't it ?*/
387  n->cfLcm = ndGcd; /* tricky, isn't it ?*/
388  n->cfInitMPZ = ndInitMPZ;
389  n->cfMPZ = ndMPZ;
390  n->cfPower = ndPower;
391  n->cfQuotRem = ndQuotRem;
392  n->cfInvers = ndInvers;
393 
394  n->cfKillChar = ndKillChar; /* dummy */
395  n->cfSetChar = ndSetChar; /* dummy */
396  // temp. removed to catch all the coeffs which miss to implement this!
397 
399  n->cfFarey = ndFarey;
400  n->cfParDeg = ndParDeg;
401 
403 
406 
407  //n->cfIsUnit = ndIsUnit;
408 #ifdef HAVE_RINGS
409  n->cfDivComp = ndDivComp;
410  n->cfDivBy = ndDivBy;
411  n->cfExtGcd = ndExtGcd;
412  //n->cfGetUnit = ndGetUnit_Ring;// set afterwards
413 #endif
414 
415 #ifdef LDEBUG
416  n->cfDBTest=ndDBTest;
417 #endif
418 
421 
422  BOOLEAN nOK=TRUE;
423  // init
424  if ((t<=nLastCoeffs) && (nInitCharTable[t]!=NULL))
425  nOK = (nInitCharTable[t])(n,parameter);
426  else
427  Werror("Sorry: the coeff type [%d] was not registered: it is missing in nInitCharTable", (int)t);
428  if (nOK)
429  {
430  omFreeSize(n,sizeof(*n));
431  return NULL;
432  }
433  cf_root=n;
434  // post init settings:
435  if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;
436  if (n->cfExactDiv==NULL) n->cfExactDiv=n->cfDiv;
437  if (n->cfSubringGcd==NULL) n->cfSubringGcd=n->cfGcd;
438  if (n->cfIsUnit==NULL)
439  {
440  if (n->is_field) n->cfIsUnit=ndIsUnit_Field;
441  else n->cfIsUnit=ndIsUnit_Ring;
442  }
443  #ifdef HAVE_RINGS
444  if (n->cfGetUnit==NULL)
445  {
446  if (n->is_field) n->cfGetUnit=n->cfCopy;
447  else n->cfGetUnit=ndGetUnit_Ring;
448  }
449  #endif
450 
451  if(n->cfWriteShort==NULL)
452  n->cfWriteShort = n->cfWriteLong;
453 
455  assume(n->cfSetChar!=NULL);
457  assume(n->cfMult!=NULL);
458  assume(n->cfSub!=NULL);
459  assume(n->cfAdd!=NULL);
460  assume(n->cfDiv!=NULL);
461  assume(n->cfIntMod!=NULL);
462  assume(n->cfExactDiv!=NULL);
463  assume(n->cfInit!=NULL);
464  assume(n->cfInitMPZ!=NULL);
465  assume(n->cfSize!=NULL);
466  assume(n->cfInt!=NULL);
467  assume(n->cfMPZ!=NULL);
468  //assume(n->n->cfDivComp!=NULL);
469  //assume(n->cfIsUnit!=NULL);
470  //assume(n->cfGetUnit!=NULL);
471  //assume(n->cfExtGcd!=NULL);
472  assume(n->cfInpNeg!=NULL);
473  assume(n->cfCopy!=NULL);
474 
475  assume(n->cfWriteLong!=NULL);
476  assume(n->cfWriteShort!=NULL);
477 
478  assume(n->iNumberOfParameters>= 0);
479 
480  assume( (n->iNumberOfParameters == 0 && n->pParameterNames == NULL) ||
481  (n->iNumberOfParameters > 0 && n->pParameterNames != NULL) );
482 
483  assume(n->cfParameter!=NULL);
484  assume(n->cfParDeg!=NULL);
485 
486  assume(n->cfRead!=NULL);
487  assume(n->cfNormalize!=NULL);
488  assume(n->cfGreater!=NULL);
489  //assume(n->cfDivBy!=NULL);
490  assume(n->cfEqual!=NULL);
491  assume(n->cfIsZero!=NULL);
492  assume(n->cfIsOne!=NULL);
493  assume(n->cfIsMOne!=NULL);
495  assume(n->cfGetDenom!=NULL);
497  assume(n->cfGcd!=NULL);
499  assume(n->cfDelete!=NULL);
500  assume(n->cfSetMap!=NULL);
501  assume(n->cfInpMult!=NULL);
502 // assume(n->cfInit_bigint!=NULL);
503  assume(n->cfCoeffWrite != NULL);
504 
505  assume(n->cfClearContent != NULL);
507 
508  assume(n->type==t);
509 
510 #ifndef SING_NDEBUG
511  if(n->cfKillChar==NULL) Warn("cfKillChar is NULL for coeff %d",t);
512  if(n->cfWriteLong==NULL) Warn("cfWrite is NULL for coeff %d",t);
513  if(n->cfWriteShort==NULL) Warn("cfWriteShort is NULL for coeff %d",t);
514 #endif
515  }
516  else
517  {
518  n->ref++;
519  }
520  return n;
#define Warn
Definition: emacs.cc:77
static BOOLEAN ndIsUnit_Field(number a, const coeffs r)
Definition: numbers.cc:119
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:276
static int ndDivComp(number, number, const coeffs)
Definition: numbers.cc:272
static number ndGetUnit_Ring(number, const coeffs r)
Definition: numbers.cc:121
static BOOLEAN ndDBTest(number, const char *, const int, const coeffs)
Definition: numbers.cc:125
number ndGcd(number, number, const coeffs r)
Definition: numbers.cc:165
static void ndKillChar(coeffs)
Definition: numbers.cc:265
static number ndConvFactoryNSingN(const CanonicalForm, const coeffs)
[in, out] a bigint number >= 0
Definition: numbers.cc:283
static void ndClearDenominators(ICoeffsEnumerator &, number &d, const coeffs r)
Definition: numbers.cc:245
static void ndClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Definition: numbers.cc:171
static int ndParDeg(number n, const coeffs r)
Definition: numbers.cc:139
static BOOLEAN ndCoeffIsEqual(const coeffs r, n_coeffType n, void *)
Definition: numbers.cc:302
static char * ndCoeffString(const coeffs r)
Definition: numbers.cc:52
static BOOLEAN ndIsUnit_Ring(number a, const coeffs r)
Definition: numbers.cc:117
static char * ndCoeffName(const coeffs r)
Definition: numbers.cc:60
void ndNormalize(number &, const coeffs)
Definition: numbers.cc:163
static int ndSize(number a, const coeffs r)
Definition: numbers.cc:169
static number ndIntMod(number, number, const coeffs r)
Definition: numbers.cc:166
static number ndFarey(number, number, const coeffs r)
Definition: numbers.cc:128
static void ndMPZ(mpz_t result, number &n, const coeffs r)
Converts a non-negative bigint number into a GMP number.
Definition: numbers.cc:291
STATIC_VAR n_coeffType nLastCoeffs
Definition: numbers.cc:316
static number ndAnn(number, const coeffs)
Definition: numbers.cc:51
static number ndGetDenom(number &, const coeffs r)
Definition: numbers.cc:167
static void ndDelete(number *d, const coeffs)
Definition: numbers.cc:50
STATIC_VAR cfInitCharProc * nInitCharTable
Definition: numbers.cc:350
static number ndParameter(const int, const coeffs r)
Definition: numbers.cc:144
static number ndCopy(number a, const coeffs)
Definition: numbers.cc:254
static void ndInpMult(number &a, number b, const coeffs r)
Definition: numbers.cc:66
static number ndChineseRemainder(number *, number *, int, BOOLEAN, CFArray &, const coeffs r)
Definition: numbers.cc:133
static number ndGetNumerator(number &a, const coeffs r)
Definition: numbers.cc:168
static BOOLEAN ndDivBy(number, number, const coeffs)
Definition: numbers.cc:271
static number ndInitMPZ(mpz_t m, const coeffs r)
Definition: numbers.cc:296
static void ndInpAdd(number &a, number b, const coeffs r)
Definition: numbers.cc:72
static number ndInvers(number a, const coeffs r)
Definition: numbers.cc:109
static void ndCoeffWrite(const coeffs r, BOOLEAN)
Definition: numbers.cc:56
static number ndReturn0(number, const coeffs r)
Definition: numbers.cc:164
static number ndExtGcd(number, number, number *, number *, const coeffs r)
Definition: numbers.cc:273
static number ndQuotRem(number a, number b, number *r, const coeffs R)
Definition: numbers.cc:309
static void ndSetChar(const coeffs)
Definition: numbers.cc:266
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc0(size)
Definition: omAllocDecl.h:211
BOOLEAN(* cfIsUnit)(number a, const coeffs r)
Definition: coeffs.h:378
number(* cfChineseRemainder)(number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs)
chinese remainder returns X with X mod q[i]=x[i], i=0..rl-1
Definition: coeffs.h:297
number(* cfNormalizeHelper)(number a, number b, const coeffs r)
Definition: coeffs.h:271
int(* cfDivComp)(number a, number b, const coeffs r)
Definition: coeffs.h:377
BOOLEAN(*)(*)(*)(*)(*)(*) cfGreaterZero(number a, const coeffs r)
Definition: coeffs.h:237
number(* cfExtGcd)(number a, number b, number *s, number *t, const coeffs r)
Definition: coeffs.h:248
number(* cfGetUnit)(number a, const coeffs r)
Definition: coeffs.h:379
number(* cfLcm)(number a, number b, const coeffs r)
Definition: coeffs.h:270
number(* cfGetNumerator)(number &n, const coeffs r)
Definition: coeffs.h:241
number(* cfInvers)(number a, const coeffs r)
return 1/a
Definition: coeffs.h:197
number(* cfInit)(long i, const coeffs r)
init with an integer
Definition: coeffs.h:178
int iNumberOfParameters
Number of Parameters in the coeffs (default 0)
Definition: coeffs.h:319
number(* cfInpNeg)(number a, const coeffs r)
changes argument inline: a:= -a return -a! (no copy is returned) the result should be assigned to the...
Definition: coeffs.h:195
number(* cfInitMPZ)(mpz_t i, const coeffs r)
init with a GMP integer
Definition: coeffs.h:181
BOOLEAN is_field
TRUE, if cf is a field.
Definition: coeffs.h:140
nMapFunc(* cfSetMap)(const coeffs src, const coeffs dst)
Definition: coeffs.h:275
number(* cfParameter)(const int i, const coeffs r)
create i^th parameter or NULL if not possible
Definition: coeffs.h:303
void(* cfSetChar)(const coeffs r)
Definition: coeffs.h:161
number(* convFactoryNSingN)(const CanonicalForm n, const coeffs r)
conversion to CanonicalForm(factory) to number
Definition: coeffs.h:315
number(* cfGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:246
number(* cfImPart)(number a, const coeffs r)
Definition: coeffs.h:201
number(* cfFarey)(number p, number n, const coeffs)
rational reconstruction: "best" rational a/b with a/b = p mod n
Definition: coeffs.h:291
number(* cfCopy)(number a, const coeffs r)
return a copy of a
Definition: coeffs.h:199
int ref
Definition: coeffs.h:126
BOOLEAN(*)(*)(*) cfIsZero(number a, const coeffs r)
Definition: coeffs.h:228
void(* cfKillChar)(coeffs r)
Definition: coeffs.h:159
BOOLEAN(*)(*) cfEqual(number a, number b, const coeffs r)
tests
Definition: coeffs.h:227
numberfunc cfIntMod
Definition: coeffs.h:175
numberfunc cfExactDiv
Definition: coeffs.h:175
void(* cfMPZ)(mpz_t result, number &n, const coeffs r)
Converts a (integer) number n into a GMP number, 0 if impossible.
Definition: coeffs.h:190
BOOLEAN(* nCoeffIsEqual)(const coeffs r, n_coeffType n, void *parameter)
Definition: coeffs.h:145
void(* cfWriteShort)(number a, const coeffs r)
print a given number in a shorter way, if possible e.g. in K(a): a2 instead of a^2
Definition: coeffs.h:208
number(* cfRePart)(number a, const coeffs r)
Definition: coeffs.h:200
void(* cfNormalize)(number &a, const coeffs r)
Definition: coeffs.h:223
numberfunc cfMult
Definition: coeffs.h:175
char *(* cfCoeffString)(const coeffs r)
string output of coeff description
Definition: coeffs.h:151
number(* cfGetDenom)(number &n, const coeffs r)
Definition: coeffs.h:240
void(* cfWriteLong)(number a, const coeffs r)
print a given number (long format)
Definition: coeffs.h:204
number(* cfSubringGcd)(number a, number b, const coeffs r)
Definition: coeffs.h:247
BOOLEAN(*)(*)(*)(*) cfIsOne(number a, const coeffs r)
Definition: coeffs.h:229
number(* cfAnn)(number a, const coeffs r)
Definition: coeffs.h:261
void(* cfPower)(number a, int i, number *result, const coeffs r)
Definition: coeffs.h:239
CanonicalForm(* convSingNFactoryN)(number n, BOOLEAN setChar, const coeffs r)
Definition: coeffs.h:316
long(* cfInt)(number &n, const coeffs r)
convertion to long, 0 if impossible
Definition: coeffs.h:187
BOOLEAN(* cfGreater)(number a, number b, const coeffs r)
Definition: coeffs.h:225
number(* cfQuotRem)(number a, number b, number *rem, const coeffs r)
Definition: coeffs.h:269
void(* cfCoeffWrite)(const coeffs r, BOOLEAN details)
output of coeff description via Print
Definition: coeffs.h:148
void(* cfDelete)(number *a, const coeffs r)
Definition: coeffs.h:272
numberfunc cfSub
Definition: coeffs.h:175
BOOLEAN(* cfDBTest)(number a, const char *f, const int l, const coeffs r)
Test: is "a" a correct number?
Definition: coeffs.h:415
n_coeffType type
Definition: coeffs.h:128
numberfunc cfAdd
Definition: coeffs.h:175
BOOLEAN(*)(*)(*)(*)(*) cfIsMOne(number a, const coeffs r)
Definition: coeffs.h:232
numberfunc cfDiv
Definition: coeffs.h:175
char const ** pParameterNames
array containing the names of Parameters (default NULL)
Definition: coeffs.h:322
int(* cfParDeg)(number x, const coeffs r)
degree for coeffcients: -1 for 0, 0 for "constants", ...
Definition: coeffs.h:300
void(* cfInpMult)(number &a, number b, const coeffs r)
Inplace: a *= b.
Definition: coeffs.h:281
int(* cfSize)(number n, const coeffs r)
how complicated, (0) => 0, or positive
Definition: coeffs.h:184
const char *(* cfRead)(const char *s, number *a, const coeffs r)
Definition: coeffs.h:221
void(* cfInpAdd)(number &a, number b, const coeffs r)
Inplace: a += b.
Definition: coeffs.h:284
BOOLEAN(* cfDivBy)(number a, number b, const coeffs r)
Definition: coeffs.h:381
nCoeffsEnumeratorFunc cfClearContent
function pointer behind n_ClearContent
Definition: coeffs.h:309
nCoeffsEnumeratorFunc cfClearDenominators
function pointer behind n_ClearDenominators
Definition: coeffs.h:312

◆ nKillChar()

void nKillChar ( coeffs  r)

undo all initialisations

Definition at line 522 of file numbers.cc.

524 {
525  if (r!=NULL)
526  {
527  r->ref--;
528  if (r->ref<=0)
529  {
530  n_Procs_s tmp;
531  n_Procs_s* n=&tmp;
532  tmp.next=cf_root;
533  while((n->next!=NULL) && (n->next!=r)) n=n->next;
534  if (n->next==r)
535  {
536  n->next=n->next->next;
537  if (cf_root==r) cf_root=n->next;
538  assume (r->cfKillChar!=NULL); r->cfKillChar(r);
539  omFreeSize((void *)r, sizeof(n_Procs_s));
540  r=NULL;
541  }
542  else
543  {
544  WarnS("cf_root list destroyed");
545  }
546  }
547  }
#define WarnS
Definition: emacs.cc:78

◆ nNew()

void nNew ( number *  d)

Definition at line 47 of file numbers.cc.

47 { *d=NULL; }

◆ nRegister()

n_coeffType nRegister ( n_coeffType  n,
cfInitCharProc  p 
)

Definition at line 549 of file numbers.cc.

551 {
552  if (n==n_unknown)
553  {
556  {
558  ((int)nLastCoeffs+1)*sizeof(cfInitCharProc));
560  ((int)nLastCoeffs)*sizeof(cfInitCharProc));
561  }
562  else
563  {
565  ((int)nLastCoeffs)*sizeof(cfInitCharProc),
566  (((int)nLastCoeffs)+1)*sizeof(cfInitCharProc));
567  }
568 
570  return nLastCoeffs;
571  }
572  else
573  {
574  if (nInitCharTable[n]!=NULL) Print("coeff %d already initialized\n",n);
575  nInitCharTable[n]=p;
576  return n;
577  }
n_coeffType
Definition: coeffs.h:27
@ n_unknown
Definition: coeffs.h:28
VAR cfInitCharProc nInitCharTableDefault[]
Definition: numbers.cc:317
BOOLEAN(* cfInitCharProc)(coeffs, void *)
initialize an object of type coeff, return FALSE in case of success
Definition: numbers.h:93
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:220

◆ nRegisterCfByName()

void nRegisterCfByName ( cfInitCfByNameProc  p,
n_coeffType  n 
)

Definition at line 590 of file numbers.cc.

592 {
593  nFindCoeffByName_p h=(nFindCoeffByName_p)omAlloc0(sizeof(*h));
594  h->p=p;
595  h->n=n;
596  h->next=nFindCoeffByName_Root;
STATIC_VAR Poly * h
Definition: janet.cc:971

Variable Documentation

◆ cf_root

VAR n_Procs_s* cf_root =NULL

Definition at line 45 of file numbers.cc.

◆ nFindCoeffByName_Root

VAR nFindCoeffByName_p nFindCoeffByName_Root =NULL

Definition at line 589 of file numbers.cc.

◆ nInitCharTable

Definition at line 350 of file numbers.cc.

◆ nInitCharTableDefault

VAR cfInitCharProc nInitCharTableDefault[]

Definition at line 317 of file numbers.cc.

◆ nLastCoeffs

STATIC_VAR n_coeffType nLastCoeffs =n_CF

Definition at line 316 of file numbers.cc.