source: git/kernel/numbers.cc @ 12ea9d

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