source: git/kernel/numbers.cc @ a48078

spielwiese
Last change on this file since a48078 was a48078, checked in by Hans Schönemann <hannes@…>, 15 years ago
*hannes: bigint -> number git-svn-id: file:///usr/local/Singular/svn/trunk@11223 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 18.4 KB
Line 
1/*****************************************
2*  Computer Algebra System SINGULAR      *
3*****************************************/
4/* $Id: numbers.cc,v 1.19 2008-12-08 17:47:35 Singular Exp $ */
5
6/*
7* ABSTRACT: interface to coefficient aritmetics
8*/
9
10#include <string.h>
11#include <stdlib.h>
12#include "mod2.h"
13#include "structs.h"
14#include "febase.h"
15#include "kstd1.h"
16#include "numbers.h"
17#include "longrat.h"
18#include "longalg.h"
19#include "modulop.h"
20#include "gnumpfl.h"
21#include "gnumpc.h"
22#include "ring.h"
23#include "ffields.h"
24#include "shortfl.h"
25#ifdef HAVE_RING2TOM
26#include "rmodulo2m.h"
27#endif
28#ifdef HAVE_RINGMODN
29#include "rmodulon.h"
30#endif
31#ifdef HAVE_RINGZ
32#include "rintegers.h"
33#endif
34
35//static int characteristic = 0;
36extern int IsPrime(int p);
37
38void   (*nNew)(number *a);
39number (*nInit)(int i);
40number  (*nInit_bigint)(number i);
41number (*nPar)(int i);
42int    (*nParDeg)(number n);
43int    (*nSize)(number n);
44int    (*nInt)(number &n);
45numberfunc nMult, nSub, nAdd, nDiv, nIntDiv, nIntMod, nExactDiv;
46number (*nNeg)(number a);
47number (*nInvers)(number a);
48void   (*nNormalize)(number &a);
49number (*nCopy)(number a);
50number (*nRePart)(number a);
51number (*nImPart)(number a);
52#ifdef HAVE_RINGS
53BOOLEAN (*nDivBy)(number a,number b);
54int     (*nDivComp)(number a,number b);
55BOOLEAN (*nIsUnit)(number a);
56number  (*nGetUnit)(number a);
57number  (*nExtGcd)(number a, number b, number *s, number *t);
58#endif
59BOOLEAN (*nGreater)(number a,number b);
60BOOLEAN (*nEqual)(number a,number b);
61BOOLEAN (*nIsZero)(number a);
62BOOLEAN (*nIsOne)(number a);
63BOOLEAN (*nIsMOne)(number a);
64BOOLEAN (*nGreaterZero)(number a);
65void    (*nWrite)(number &a);
66const char* (*nRead)(const char *s,number *a);
67void    (*nPower)(number a, int i, number * result);
68number  (*nGcd)(number a, number b, const ring r);
69number  (*nLcm)(number a, number b, const ring r);
70char * (*nName)(number n);
71void   (*n__Delete)(number *a, const ring r);
72
73/*0 implementation*/
74number nNULL; /* the 0 as constant */
75
76n_Procs_s *cf_root=NULL;
77
78void   nDummy1(number* d) { *d=NULL; }
79void   ndDelete(number* d, const ring r) { *d=NULL; }
80void   ndInpMult(number &a, number b, const ring r)
81{
82  number n=n_Mult(a,b,r);
83  n_Delete(&a,r);
84  a=n;
85}
86number ndInpAdd(number &a, number b, const ring r)
87{
88  number n=n_Add(a,b,r);
89  n_Delete(&a,r);
90  a=n;
91  return a;
92}
93
94#ifdef LDEBUG
95void   nDBDummy1(number* d,char *f, int l) { *d=NULL; }
96BOOLEAN ndDBTest(number a, const char *f, const int l)
97{
98  return TRUE;
99}
100#endif
101
102void   nDummy2(number& d) { }
103
104char * ndName(number n) { return NULL; }
105
106number ndPar(int i) { return nInit(0); }
107
108number ndReturn0(number n) { return nInit(0); }
109
110int    ndParDeg(number n) { return 0; }
111
112number ndGcd(number a, number b, const ring r) { return r->cf->nInit(1); }
113
114number ndIntMod(number a, number b) { return nInit(0); }
115
116number ndGetDenom(number &n, const ring r) { return n_Init(1,r); }
117
118int ndSize(number a) { return (int)nIsZero(a)==FALSE; }
119
120number ndCopy(number a) { return a; }
121number nd_Copy(number a,const ring r) { return r->cf->nCopy(a); }
122
123#ifdef HAVE_RINGS
124BOOLEAN ndDivBy(number a, number b) { return TRUE; } // assume a,b !=0
125int ndDivComp(number a, number b) { return 0; }
126BOOLEAN ndIsUnit(number a) { return !nIsZero(a); }
127number  ndExtGcd (number a, number b, number *s, number *t) { return nInit(1); }
128#endif
129
130/*2
131* init operations for characteristic c (complete==TRUE)
132* init nDelete    for characteristic c (complete==FALSE)
133*/
134void nSetChar(ring r)
135{
136  int c=rInternalChar(r);
137
138  n__Delete= r->cf->cfDelete;
139  if (rField_is_Extension(r))
140  {
141    naSetChar(c,r);
142    if (rField_is_Q_a()) nInit_bigint=naMap00;
143    if (rField_is_Zp_a()) nInit_bigint=naMap0P;
144  }
145#ifdef HAVE_RING2TOM
146  /*----------------------ring Z / 2^m----------------*/
147  else if (rField_is_Ring_2toM(r))
148  {
149    nr2mSetExp(c, r);
150    nInit_bigint=nr2mMapQ;
151  }
152#endif 
153#ifdef HAVE_RINGZ
154  /*----------------------ring Z / 2^m----------------*/
155  else if (rField_is_Ring_Z(r))
156  {
157    nrzSetExp(c, r);
158    nInit_bigint=nrzMapQ;
159  }
160#endif 
161#ifdef HAVE_RINGMODN
162  /*----------------------ring Z / n----------------*/
163  else if (rField_is_Ring_ModN(r))
164  {
165    nrnSetExp(c, r);
166    nInit_bigint=nrnMapQ;
167  }
168#endif
169#ifdef HAVE_RINGMODN
170  /*----------------------ring Z / n----------------*/
171  else if (rField_is_Ring_PtoM(r))
172  {
173    nrnSetExp(c, r);
174    nInit_bigint=nrnMapQ;
175  }
176#endif
177  else if (rField_is_Zp(r))
178  /*----------------------char. p----------------*/
179  {
180    npSetChar(c, r);
181    nInit_bigint=npMap0;
182  }
183  /* -------------- GF(p^m) -----------------------*/
184  else if (rField_is_GF(r))
185  {
186    nfSetChar(c,r->parameter);
187    nInit_bigint=ndReturn0; // not impl.
188  }
189  /* -------------- R -----------------------*/
190  //if (c==(-1))
191  else if (rField_is_R(r))
192  {
193    nInit_bigint=nrMapQ;
194  }
195  /* -------------- long R -----------------------*/
196  /* -------------- long C -----------------------*/
197  else if ((rField_is_long_R(r))
198  || (rField_is_long_C(r)))
199  {
200    setGMPFloatDigits(r->float_len,r->float_len2);
201    if (rField_is_long_R(r)) nInit_bigint=ngfMapQ;
202    else                     nInit_bigint=ngcMapQ;
203  }
204#ifdef TEST
205  /* -------------- R -----------------------*/
206  //if (c==(-1))
207  else if (!rField_is_R(r) && !rField_is_Q(r))
208  {
209    WerrorS("unknown field");
210  }
211#endif
212  nNew   = r->cf->nNew;
213  nNormalize=r->cf->nNormalize;
214  nInit  = r->cf->nInit;
215  nPar   = r->cf->nPar;
216  nParDeg= r->cf->nParDeg;
217  nInt   = r->cf->nInt;
218  nAdd   = r->cf->nAdd;
219  nSub   = r->cf->nSub;
220  nMult  = r->cf->nMult;
221  nDiv   = r->cf->nDiv;
222  nExactDiv= r->cf->nExactDiv;
223  nIntDiv= r->cf->nIntDiv;
224  nIntMod= r->cf->nIntMod;
225  nNeg   = r->cf->nNeg;
226  nInvers= r->cf->nInvers;
227  nCopy  = r->cf->nCopy;
228#ifdef HAVE_RINGS
229  nDivComp  = r->cf->nDivComp;
230  nDivBy = r->cf->nDivBy;
231  nIsUnit = r->cf->nIsUnit;
232  nGetUnit = r->cf->nGetUnit;
233  nExtGcd = r->cf->nExtGcd;
234#endif
235  nGreater = r->cf->nGreater;
236  nEqual = r->cf->nEqual;
237  nIsZero = r->cf->nIsZero;
238  nIsOne = r->cf->nIsOne;
239  nIsMOne = r->cf->nIsMOne;
240  nGreaterZero = r->cf->nGreaterZero;
241  nWrite = r->cf->nWrite;
242  nRead = r->cf->nRead;
243  nPower = r->cf->nPower;
244  nGcd  = r->cf->nGcd;
245  nLcm  = r->cf->nLcm;
246  nName= r->cf->nName;
247  nSize  = r->cf->nSize;
248  nRePart = r->cf->nRePart;
249  nImPart = r->cf->nImPart;
250  nNULL=r->cf->nNULL;
251}
252
253/*2
254* init operations for ring r
255*/
256void nInitChar(ring r)
257{
258  int c=rInternalChar(r);
259  n_coeffType t=rFieldType(r);
260
261  if (rField_is_Extension(r))
262  {
263    if (r->algring==NULL)
264    {
265      int ch=-c;
266      if (c==1) ch=0;
267      r->algring=(ring) rDefault(ch,r->P,r->parameter);
268      //r->algring->ShortOut=r->ShortOut;
269      // includes: nInitChar(r->algring);
270    }
271  }
272
273  n_Procs_s *n=cf_root;
274  while((n!=NULL)
275    && ((n->nChar!=c) || (n->type!=t)))
276      n=n->next;
277  if (n==NULL)
278  {
279    n=(n_Procs_s*)omAlloc0(sizeof(n_Procs_s));
280    n->next=cf_root;
281    n->ref=1;
282    n->nChar=c;
283    n->type=t;
284    cf_root=n;
285  }
286  else if ((n->nChar==c) && (n->type==t))
287  {
288    n->ref++;
289    r->cf=n;
290    return;
291  }
292  else
293  {
294    WerrorS("nInitChar failed");
295    return;
296  }
297  r->cf=n;
298  n->nChar = c;
299  n->nPar  = ndPar;
300  n->nParDeg=ndParDeg;
301  n->nSize = ndSize;
302  n->n_GetDenom= ndGetDenom;
303  n->nName =  ndName;
304  n->nImPart=ndReturn0;
305  n->cfDelete= ndDelete;
306  n->nNew=nDummy1;
307  n->nInpMult=ndInpMult;
308  n->cfCopy=nd_Copy;
309  n->nIntMod=ndIntMod; /* dummy !! */
310  n->nNormalize=nDummy2;
311  n->nGcd  = ndGcd;
312  n->nLcm  = ndGcd; /* tricky, isn't it ?*/
313#ifdef HAVE_RINGS
314  n->nDivComp = ndDivComp;
315  n->nDivBy = ndDivBy;
316  n->nIsUnit = ndIsUnit;
317  n->nExtGcd = ndExtGcd;
318  n->nGetUnit = (nMapFunc)NULL;
319#endif
320  if (rField_is_Extension(r))
321  {
322    //naInitChar(c,TRUE,r);
323    n->cfDelete = naDelete;
324    n-> nNew       = naNew;
325    n-> nNormalize = naNormalize;
326    n->nInit       = naInit;
327    n->nPar        = naPar;
328    n->nParDeg     = naParDeg;
329    n->nInt        = naInt;
330    n->nAdd        = naAdd;
331    n->nSub        = naSub;
332    n->nMult       = naMult;
333    n->nDiv        = naDiv;
334    n->nExactDiv   = naDiv;
335    n->nIntDiv     = naIntDiv;
336    n->nNeg        = naNeg;
337    n->nInvers     = naInvers;
338    n->nCopy       = naCopy;
339    n->cfCopy      = na_Copy;
340    n->nGreater    = naGreater;
341    n->nEqual      = naEqual;
342    n->nIsZero     = naIsZero;
343    n->nIsOne      = naIsOne;
344    n->nIsMOne     = naIsMOne;
345    n->nGreaterZero= naGreaterZero;
346    n->nWrite      = naWrite;
347    n->nRead       = naRead;
348    n->nPower      = naPower;
349    n->nGcd        = naGcd;
350    n->nLcm        = naLcm;
351    n->cfSetMap    = naSetMap;
352    n->nName       = naName;
353    n->nSize       = naSize;
354    n->n_GetDenom   = naGetDenom;
355#ifdef LDEBUG
356    n->nDBTest     = naDBTest;
357#endif
358  }
359#ifdef HAVE_RING2TOM
360  /* -------------- Z/2^m ----------------------- */
361  else if (rField_is_Ring_2toM(r))
362  {
363     nr2mInitExp(c,r);
364     n->nInit  = nr2mInit;
365     n->nCopy  = ndCopy;
366     n->nInt   = nr2mInt;
367     n->nAdd   = nr2mAdd;
368     n->nSub   = nr2mSub;
369     n->nMult  = nr2mMult;
370     n->nDiv   = nr2mDiv;
371     n->nIntDiv       = nr2mIntDiv;
372     n->nExactDiv= nr2mDiv;
373     n->nNeg   = nr2mNeg;
374     n->nInvers= nr2mInvers;
375     n->nDivBy = nr2mDivBy;
376     n->nDivComp = nr2mDivComp;
377     n->nGreater = nr2mGreater;
378     n->nEqual = nr2mEqual;
379     n->nIsZero = nr2mIsZero;
380     n->nIsOne = nr2mIsOne;
381     n->nIsMOne = nr2mIsMOne;
382     n->nGreaterZero = nr2mGreaterZero;
383     n->nWrite = nr2mWrite;
384     n->nRead = nr2mRead;
385     n->nPower = nr2mPower;
386     n->cfSetMap = nr2mSetMap;
387     n->nNormalize = nDummy2;
388     n->nLcm          = nr2mLcm;
389     n->nGcd          = nr2mGcd;
390     n->nIsUnit = nr2mIsUnit;
391     n->nGetUnit = nr2mGetUnit;
392     n->nExtGcd = nr2mExtGcd;
393     n->nName= ndName;
394#ifdef LDEBUG
395     n->nDBTest=nr2mDBTest;
396#endif
397  }
398#endif
399#ifdef HAVE_RINGMODN
400  /* -------------- Z/n ----------------------- */
401  else if (rField_is_Ring_ModN(r) || rField_is_Ring_PtoM(r)
402  )
403  {
404     nrnInitExp(c,r);
405     n->nInit  = nrnInit;
406     n->cfDelete= nrnDelete;
407     n->nCopy  = nrnCopy;
408     n->cfCopy = cfrnCopy;
409     n->nSize  = nrnSize;
410     n->nInt   = nrnInt;
411     n->nAdd   = nrnAdd;
412     n->nSub   = nrnSub;
413     n->nMult  = nrnMult;
414     n->nDiv   = nrnDiv;
415     n->nIntDiv= nrnIntDiv;
416     n->nExactDiv= nrnDiv;
417     n->nNeg   = nrnNeg;
418     n->nInvers= nrnInvers;
419     n->nDivBy = nrnDivBy;
420     n->nDivComp = nrnDivComp;
421     n->nGreater = nrnGreater;
422     n->nEqual = nrnEqual;
423     n->nIsZero = nrnIsZero;
424     n->nIsOne = nrnIsOne;
425     n->nIsMOne = nrnIsMOne;
426     n->nGreaterZero = nrnGreaterZero;
427     n->nWrite = nrnWrite;
428     n->nRead = nrnRead;
429     n->nPower = nrnPower;
430     n->cfSetMap = nrnSetMap;
431     n->nNormalize = nDummy2;
432     n->nLcm          = nrnLcm;
433     n->nGcd          = nrnGcd;
434     n->nIsUnit = nrnIsUnit;
435     n->nGetUnit = nrnGetUnit;
436     n->nExtGcd = nrnExtGcd;
437     n->nName= ndName;
438#ifdef LDEBUG
439     n->nDBTest=nrnDBTest;
440#endif
441  }
442#endif
443#ifdef HAVE_RINGZ
444  /* -------------- Z ----------------------- */
445  else if (rField_is_Ring_Z(r))
446  {
447     n->nInit  = nrzInit;
448     n->cfDelete= nrzDelete;
449     n->nCopy  = nrzCopy;
450     n->cfCopy = cfrzCopy;
451     n->nSize  = nrzSize;
452     n->nInt   = nrzInt;
453     n->nAdd   = nrzAdd;
454     n->nSub   = nrzSub;
455     n->nMult  = nrzMult;
456     n->nDiv   = nrzDiv;
457     n->nIntDiv       = nrzIntDiv;
458     n->nExactDiv= nrzDiv;
459     n->nNeg   = nrzNeg;
460     n->nInvers= nrzInvers;
461     n->nDivBy = nrzDivBy;
462     n->nDivComp = nrzDivComp;
463     n->nGreater = nrzGreater;
464     n->nEqual = nrzEqual;
465     n->nIsZero = nrzIsZero;
466     n->nIsOne = nrzIsOne;
467     n->nIsMOne = nrzIsMOne;
468     n->nGreaterZero = nrzGreaterZero;
469     n->nWrite = nrzWrite;
470     n->nRead = nrzRead;
471     n->nPower = nrzPower;
472     n->cfSetMap = nrzSetMap;
473     n->nNormalize = nDummy2;
474     n->nLcm          = nrzLcm;
475     n->nGcd          = nrzGcd;
476     n->nIsUnit = nrzIsUnit;
477     n->nGetUnit = nrzGetUnit;
478     n->nExtGcd = nrzExtGcd;
479     n->nName= ndName;
480#ifdef LDEBUG
481     n->nDBTest=ndDBTest; // not yet implemented: nrzDBTest;
482#endif
483  }
484#endif
485  else if (rField_is_Q(r))
486  {
487    n->cfDelete= nlDelete;
488    n->nNew   = nlNew;
489    n->nNormalize=nlNormalize;
490    n->nInit  = nlInit;
491    n->nInt   = nlInt;
492    n->nAdd   = nlAdd;
493    n->nSub   = nlSub;
494    n->nMult  = nlMult;
495    n->nInpMult=nlInpMult;
496    n->nDiv   = nlDiv;
497    n->nExactDiv= nlExactDiv;
498    n->nIntDiv= nlIntDiv;
499    n->nIntMod= nlIntMod;
500    n->nNeg   = nlNeg;
501    n->nInvers= nlInvers;
502    n->nCopy  = nlCopy;
503    n->nGreater = nlGreater;
504    n->nEqual = nlEqual;
505    n->nIsZero = nlIsZero;
506    n->nIsOne = nlIsOne;
507    n->nIsMOne = nlIsMOne;
508    n->nGreaterZero = nlGreaterZero;
509    n->nWrite = nlWrite;
510    n->nRead = nlRead;
511    n->nPower = nlPower;
512    n->nGcd  = nlGcd;
513    n->nLcm  = nlLcm;
514    n->cfSetMap = nlSetMap;
515    n->nSize  = nlSize;
516    n->n_GetDenom = nlGetDenom;
517#ifdef LDEBUG
518    n->nDBTest=nlDBTest;
519#endif
520  }
521  else if (rField_is_Zp(r))
522  /*----------------------char. p----------------*/
523  {
524    npInitChar(c,r);
525    n->nInit  = npInit;
526    n->nInt   = npInt;
527    n->nAdd   = npAdd;
528    n->nSub   = npSub;
529    n->nMult  = npMult;
530    n->nDiv   = npDiv;
531    n->nExactDiv= npDiv;
532    n->nNeg   = npNeg;
533    n->nInvers= npInvers;
534    n->nCopy  = ndCopy;
535    n->nGreater = npGreater;
536    n->nEqual = npEqual;
537    n->nIsZero = npIsZero;
538    n->nIsOne = npIsOne;
539    n->nIsMOne = npIsMOne;
540    n->nGreaterZero = npGreaterZero;
541    n->nWrite = npWrite;
542    n->nRead = npRead;
543    n->nPower = npPower;
544    n->cfSetMap = npSetMap;
545    /* nName= ndName; */
546    /*nSize  = ndSize;*/
547#ifdef LDEBUG
548    n->nDBTest=npDBTest;
549#endif
550#ifdef NV_OPS
551    if (c>NV_MAX_PRIME)
552    {
553      n->nMult  = nvMult;
554      n->nDiv   = nvDiv;
555      n->nExactDiv= nvDiv;
556      n->nInvers= nvInvers;
557    }
558#endif
559  }
560  /* -------------- GF(p^m) -----------------------*/
561  else if (rField_is_GF(r))
562  {
563    //nfSetChar(c,r->parameter);
564    n->nInit  = nfInit;
565    n->nPar   = nfPar;
566    n->nParDeg= nfParDeg;
567    n->nInt   = nfInt;
568    n->nAdd   = nfAdd;
569    n->nSub   = nfSub;
570    n->nMult  = nfMult;
571    n->nDiv   = nfDiv;
572    n->nExactDiv= nfDiv;
573    n->nNeg   = nfNeg;
574    n->nInvers= nfInvers;
575    n->nCopy  = ndCopy;
576    n->nGreater = nfGreater;
577    n->nEqual = nfEqual;
578    n->nIsZero = nfIsZero;
579    n->nIsOne = nfIsOne;
580    n->nIsMOne = nfIsMOne;
581    n->nGreaterZero = nfGreaterZero;
582    n->nWrite = nfWrite;
583    n->nRead = nfRead;
584    n->nPower = nfPower;
585    n->cfSetMap = nfSetMap;
586    n->nName= nfName;
587    /*nSize  = ndSize;*/
588#ifdef LDEBUG
589    n->nDBTest=nfDBTest;
590#endif
591  }
592  /* -------------- R -----------------------*/
593  //if (c==(-1))
594  else if (rField_is_R(r))
595  {
596    n->nInit  = nrInit;
597    n->nInt   = nrInt;
598    n->nAdd   = nrAdd;
599    n->nSub   = nrSub;
600    n->nMult  = nrMult;
601    n->nDiv   = nrDiv;
602    n->nExactDiv= nrDiv;
603    n->nNeg   = nrNeg;
604    n->nInvers= nrInvers;
605    n->nCopy  = ndCopy;
606    n->nGreater = nrGreater;
607    n->nEqual = nrEqual;
608    n->nIsZero = nrIsZero;
609    n->nIsOne = nrIsOne;
610    n->nIsMOne = nrIsMOne;
611    n->nGreaterZero = nrGreaterZero;
612    n->nWrite = nrWrite;
613    n->nRead = nrRead;
614    n->nPower = nrPower;
615    n->cfSetMap=nrSetMap;
616    /* nName= ndName; */
617    /*nSize  = ndSize;*/
618#ifdef LDEBUG
619    n->nDBTest=ndDBTest; // not yet implemented: nrDBTest;
620#endif
621  }
622  /* -------------- long R -----------------------*/
623  else if (rField_is_long_R(r))
624  {
625    n->cfDelete= ngfDelete;
626    n->nNew=ngfNew;
627    n->nInit  = ngfInit;
628    n->nInt   = ngfInt;
629    n->nAdd   = ngfAdd;
630    n->nSub   = ngfSub;
631    n->nMult  = ngfMult;
632    n->nDiv   = ngfDiv;
633    n->nExactDiv= ngfDiv;
634    n->nNeg   = ngfNeg;
635    n->nInvers= ngfInvers;
636    n->nCopy  = ngfCopy;
637    n->nGreater = ngfGreater;
638    n->nEqual = ngfEqual;
639    n->nIsZero = ngfIsZero;
640    n->nIsOne = ngfIsOne;
641    n->nIsMOne = ngfIsMOne;
642    n->nGreaterZero = ngfGreaterZero;
643    n->nWrite = ngfWrite;
644    n->nRead = ngfRead;
645    n->nPower = ngfPower;
646    n->cfSetMap=ngfSetMap;
647    n->nName= ndName;
648    n->nSize  = ndSize;
649#ifdef LDEBUG
650    n->nDBTest=ndDBTest; // not yet implemented: ngfDBTest
651#endif
652  }
653  /* -------------- long C -----------------------*/
654  else if (rField_is_long_C(r))
655  {
656    n->cfDelete= ngcDelete;
657    n->nNew=ngcNew;
658    n->nNormalize=nDummy2;
659    n->nInit  = ngcInit;
660    n->nInt   = ngcInt;
661    n->nAdd   = ngcAdd;
662    n->nSub   = ngcSub;
663    n->nMult  = ngcMult;
664    n->nDiv   = ngcDiv;
665    n->nExactDiv= ngcDiv;
666    n->nNeg   = ngcNeg;
667    n->nInvers= ngcInvers;
668    n->nCopy  = ngcCopy;
669    n->nGreater = ngcGreater;
670    n->nEqual = ngcEqual;
671    n->nIsZero = ngcIsZero;
672    n->nIsOne = ngcIsOne;
673    n->nIsMOne = ngcIsMOne;
674    n->nGreaterZero = ngcGreaterZero;
675    n->nWrite = ngcWrite;
676    n->nRead = ngcRead;
677    n->nPower = ngcPower;
678    n->cfSetMap=ngcSetMap;
679    n->nPar=ngcPar;
680    n->nRePart=ngcRePart;
681    n->nImPart=ngcImPart;
682    /*nSize  = ndSize;*/
683#ifdef LDEBUG
684    n->nDBTest=ndDBTest; // not yet implemented: ngcDBTest
685#endif
686  }
687#ifdef TEST
688  else
689  {
690    WerrorS("unknown field");
691  }
692#endif
693#ifdef HAVE_RINGS
694  if (n->nGetUnit==(nMapFunc)NULL) n->nGetUnit=n->nCopy;
695#endif
696  if (!errorreported)
697  {
698    n->nNULL=n->nInit(0);
699    if (n->nRePart==NULL)
700      n->nRePart=n->nCopy;
701    if (n->nIntDiv==NULL)
702      n->nIntDiv=n->nDiv;
703  }
704}
705
706void nKillChar(ring r)
707{
708  if (r!=NULL)
709  {
710    if (r->cf!=NULL)
711    {
712      r->cf->ref--;
713      if (r->cf->ref<=0)
714      {
715        n_Procs_s tmp;
716        n_Procs_s* n=&tmp;
717        tmp.next=cf_root;
718        while((n->next!=NULL) && (n->next!=r->cf)) n=n->next;
719        if (n->next==r->cf)
720        {
721          n->next=n->next->next;
722          if (cf_root==r->cf) cf_root=n->next;
723          r->cf->cfDelete(&(r->cf->nNULL),r);
724          switch(r->cf->type)
725          {
726            case n_Zp:
727                 #ifdef HAVE_DIV_MOD
728                 if (r->cf->npInvTable!=NULL)
729                 omFreeSize( (ADDRESS)r->cf->npInvTable,
730                             r->cf->npPrimeM*sizeof(CARDINAL) );
731                 #else
732                 if (r->cf->npExpTable!=NULL)
733                 {
734                   omFreeSize( (ADDRESS)r->cf->npExpTable,
735                               r->cf->npPrimeM*sizeof(CARDINAL) );
736                   omFreeSize( (ADDRESS)r->cf->npLogTable,
737                               r->cf->npPrimeM*sizeof(CARDINAL) );
738                 }
739                 #endif
740                 break;
741            case n_Zp_a:
742            case n_Q_a:
743                 {
744                   number n=r->minpoly;
745                   if (n!=NULL)
746                   {
747                     r->minpoly=NULL;
748                     if (r==currRing) naMinimalPoly=NULL;
749                     naDelete(&n,r);
750                   }
751                 }
752                 break;
753
754            default:
755                 break;
756          }
757          omFreeSize((ADDRESS)r->cf, sizeof(n_Procs_s));
758          r->cf=NULL;
759        }
760        else
761        {
762          WarnS("cf_root list destroyed");
763        }
764      }
765    }
766    if (r->algring!=NULL)
767    {
768      rKill(r->algring);
769      r->algring=NULL;
770    }
771  }
772}
Note: See TracBrowser for help on using the repository browser.