My Project
Macros | Functions | Variables
rmodulon.cc File Reference
#include "misc/auxiliary.h"
#include "misc/mylimits.h"
#include "misc/prime.h"
#include "reporter/reporter.h"
#include "coeffs/si_gmp.h"
#include "coeffs/coeffs.h"
#include "coeffs/modulop.h"
#include "coeffs/rintegers.h"
#include "coeffs/numbers.h"
#include "coeffs/mpr_complex.h"
#include "coeffs/longrat.h"
#include "coeffs/rmodulon.h"
#include <string.h>

Go to the source code of this file.

Macros

#define nrnDelete   nrzDelete
 
#define nrnSize   nrzSize
 

Functions

void nrnWrite (number a, const coeffs)
 
BOOLEAN nrnDBTest (number a, const char *f, const int l, const coeffs r)
 
coeffs nrnInitCfByName (char *s, n_coeffType)
 
static char * nrnCoeffName (const coeffs r)
 
static BOOLEAN nrnCoeffIsEqual (const coeffs r, n_coeffType n, void *parameter)
 
static void nrnKillChar (coeffs r)
 
static coeffs nrnQuot1 (number c, const coeffs r)
 
static number nrnCopy (number a, const coeffs)
 
static number nrnInit (long i, const coeffs r)
 
static long nrnInt (number &n, const coeffs)
 
static number nrnMult (number a, number b, const coeffs r)
 
static void nrnPower (number a, int i, number *result, const coeffs r)
 
static number nrnAdd (number a, number b, const coeffs r)
 
static number nrnSub (number a, number b, const coeffs r)
 
static BOOLEAN nrnIsZero (number a, const coeffs)
 
static number nrnNeg (number c, const coeffs r)
 
static number nrnInvers (number c, const coeffs r)
 
static number nrnGcd (number a, number b, const coeffs r)
 
static number nrnLcm (number a, number b, const coeffs r)
 
static number nrnExtGcd (number a, number b, number *s, number *t, const coeffs r)
 
static BOOLEAN nrnIsOne (number a, const coeffs)
 
static BOOLEAN nrnEqual (number a, number b, const coeffs)
 
static number nrnGetUnit (number k, const coeffs r)
 
static number nrnXExtGcd (number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
 
static BOOLEAN nrnIsMOne (number a, const coeffs r)
 
static BOOLEAN nrnGreater (number a, number b, const coeffs)
 
static BOOLEAN nrnGreaterZero (number k, const coeffs cf)
 
static BOOLEAN nrnIsUnit (number a, const coeffs r)
 
static number nrnAnn (number k, const coeffs r)
 
static BOOLEAN nrnDivBy (number a, number b, const coeffs r)
 
static int nrnDivComp (number a, number b, const coeffs r)
 
static number nrnDiv (number a, number b, const coeffs r)
 
static number nrnMod (number a, number b, const coeffs r)
 
static number nrnQuotRem (number a, number b, number *rem, const coeffs r)
 
static number nrnMapModN (number from, const coeffs, const coeffs dst)
 
static number nrnMap2toM (number from, const coeffs, const coeffs dst)
 
static number nrnMapZp (number from, const coeffs, const coeffs dst)
 
number nrnMapGMP (number from, const coeffs, const coeffs dst)
 
static number nrnMapQ (number from, const coeffs src, const coeffs dst)
 
static number nrnMapZ (number from, const coeffs src, const coeffs dst)
 
nMapFunc nrnSetMap (const coeffs src, const coeffs dst)
 
static number nrnInitMPZ (mpz_t m, const coeffs r)
 
static void nrnMPZ (mpz_t m, number &n, const coeffs)
 
static void nrnSetExp (unsigned long m, coeffs r)
 
static void nrnInitExp (unsigned long m, coeffs r)
 
static const char * nlCPEatLongC (char *s, mpz_ptr i)
 
static const char * nrnRead (const char *s, number *a, const coeffs r)
 
static number nrnConvFactoryNSingN (const CanonicalForm n, const coeffs r)
 
static CanonicalForm nrnConvSingNFactoryN (number n, BOOLEAN setChar, const coeffs r)
 
BOOLEAN nrnInitChar (coeffs r, void *p)
 

Variables

EXTERN_VAR omBin gmp_nrz_bin
 
STATIC_VAR char * nrnCoeffName_buff =NULL
 
STATIC_VAR mpz_ptr nrnMapCoef = NULL
 

Macro Definition Documentation

◆ nrnDelete

#define nrnDelete   nrzDelete

Definition at line 177 of file rmodulon.cc.

◆ nrnSize

#define nrnSize   nrzSize

Definition at line 178 of file rmodulon.cc.

Function Documentation

◆ nlCPEatLongC()

static const char* nlCPEatLongC ( char *  s,
mpz_ptr  i 
)
static

Definition at line 922 of file rmodulon.cc.

923 {
924  const char * start=s;
925  if (!(*s >= '0' && *s <= '9'))
926  {
927  mpz_init_set_ui(i, 1);
928  return s;
929  }
930  mpz_init(i);
931  while (*s >= '0' && *s <= '9') s++;
932  if (*s=='\0')
933  {
934  mpz_set_str(i,start,10);
935  }
936  else
937  {
938  char c=*s;
939  *s='\0';
940  mpz_set_str(i,start,10);
941  *s=c;
942  }
943  return s;
944 }
int i
Definition: cfEzgcd.cc:132
const CanonicalForm int s
Definition: facAbsFact.cc:51

◆ nrnAdd()

static number nrnAdd ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 217 of file rmodulon.cc.

218 {
219  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
220  mpz_init(erg);
221  mpz_add(erg, (mpz_ptr)a, (mpz_ptr) b);
222  mpz_mod(erg, erg, r->modNumber);
223  return (number) erg;
224 }
CanonicalForm b
Definition: cfModGcd.cc:4103
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
EXTERN_VAR omBin gmp_nrz_bin
Definition: rmodulon.cc:33

◆ nrnAnn()

static number nrnAnn ( number  k,
const coeffs  r 
)
static

Definition at line 542 of file rmodulon.cc.

543 {
544  mpz_ptr tmp = (mpz_ptr) omAllocBin(gmp_nrz_bin);
545  mpz_init(tmp);
546  mpz_gcd(tmp, (mpz_ptr) k, r->modNumber);
547  if (mpz_cmp_si(tmp, 1)==0)
548  {
549  mpz_set_ui(tmp, 0);
550  return (number) tmp;
551  }
552  mpz_divexact(tmp, r->modNumber, tmp);
553  return (number) tmp;
554 }
int k
Definition: cfEzgcd.cc:99

◆ nrnCoeffIsEqual()

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

Definition at line 89 of file rmodulon.cc.

90 {
91  /* test, if r is an instance of nInitCoeffs(n,parameter) */
92  ZnmInfo *info=(ZnmInfo*)parameter;
93  return (n==r->type) && (r->modExponent==info->exp)
94  && (mpz_cmp(r->modBase,info->base)==0);
95 }
const ExtensionInfo & info
< [in] sqrfree poly

◆ nrnCoeffName()

static char* nrnCoeffName ( const coeffs  r)
static

Definition at line 66 of file rmodulon.cc.

67 {
69  size_t l = (size_t)mpz_sizeinbase(r->modBase, 10) + 2;
70  char* s = (char*) omAlloc(l);
71  l+=24;
72  nrnCoeffName_buff=(char*)omAlloc(l);
73  s= mpz_get_str (s, 10, r->modBase);
74  int ll;
75  if (nCoeff_is_Zn(r))
76  {
77  if (strlen(s)<10)
78  ll=snprintf(nrnCoeffName_buff,l,"ZZ/(%s)",s);
79  else
80  ll=snprintf(nrnCoeffName_buff,l,"ZZ/bigint(%s)",s);
81  }
82  else if (nCoeff_is_Ring_PtoM(r))
83  ll=snprintf(nrnCoeffName_buff,l,"ZZ/(bigint(%s)^%lu)",s,r->modExponent);
84  assume(ll<(int)l); // otherwise nrnCoeffName_buff too small
85  omFreeSize((ADDRESS)s, l-22);
86  return nrnCoeffName_buff;
87 }
void * ADDRESS
Definition: auxiliary.h:119
int l
Definition: cfEzgcd.cc:100
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
Definition: coeffs.h:727
static FORCE_INLINE BOOLEAN nCoeff_is_Zn(const coeffs r)
Definition: coeffs.h:826
#define assume(x)
Definition: mod2.h:387
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omFree(addr)
Definition: omAllocDecl.h:261
#define NULL
Definition: omList.c:12
STATIC_VAR char * nrnCoeffName_buff
Definition: rmodulon.cc:65

◆ nrnConvFactoryNSingN()

static number nrnConvFactoryNSingN ( const CanonicalForm  n,
const coeffs  r 
)
static

Definition at line 972 of file rmodulon.cc.

973 {
974  return nrnInit(n.intval(),r);
975 }
long intval() const
conversion functions
static number nrnInit(long i, const coeffs r)
Definition: rmodulon.cc:160

◆ nrnConvSingNFactoryN()

static CanonicalForm nrnConvSingNFactoryN ( number  n,
BOOLEAN  setChar,
const coeffs  r 
)
static

Definition at line 977 of file rmodulon.cc.

978 {
979  if (setChar) setCharacteristic( r->ch );
980  return CanonicalForm(nrnInt( n,r ));
981 }
void FACTORY_PUBLIC setCharacteristic(int c)
Definition: cf_char.cc:28
factory's main class
Definition: canonicalform.h:86
static long nrnInt(number &n, const coeffs)
Definition: rmodulon.cc:171

◆ nrnCopy()

static number nrnCopy ( number  a,
const  coeffs 
)
static

Definition at line 150 of file rmodulon.cc.

151 {
152  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
153  mpz_init_set(erg, (mpz_ptr) a);
154  return (number) erg;
155 }

◆ nrnDBTest()

BOOLEAN nrnDBTest ( number  a,
const char *  f,
const int  l,
const coeffs  r 
)

Definition at line 908 of file rmodulon.cc.

909 {
910  if ( (mpz_sgn1((mpz_ptr) a) < 0) || (mpz_cmp((mpz_ptr) a, r->modNumber) > 0) )
911  {
912  Warn("mod-n: out of range at %s:%d\n",f,l);
913  return FALSE;
914  }
915  return TRUE;
916 }
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
FILE * f
Definition: checklibs.c:9
#define Warn
Definition: emacs.cc:77
#define mpz_sgn1(A)
Definition: si_gmp.h:13

◆ nrnDiv()

static number nrnDiv ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 574 of file rmodulon.cc.

575 {
576  if (nrnIsZero(b,r))
577  {
578  WerrorS(nDivBy0);
579  return nrnInit(0,r);
580  }
581  else if (r->is_field)
582  {
583  number inv=nrnInvers(b,r);
584  number erg=nrnMult(a,inv,r);
585  nrnDelete(&inv,r);
586  return erg;
587  }
588  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
589  mpz_init(erg);
590  if (mpz_divisible_p((mpz_ptr)a, (mpz_ptr)b))
591  {
592  mpz_divexact(erg, (mpz_ptr)a, (mpz_ptr)b);
593  return (number)erg;
594  }
595  else
596  {
597  mpz_ptr gcd = (mpz_ptr)nrnGcd(a, b, r);
598  mpz_divexact(erg, (mpz_ptr)b, gcd);
599  if (!nrnIsUnit((number)erg, r))
600  {
601  WerrorS("Division not possible, even by cancelling zero divisors.");
602  nrnDelete((number*) &gcd, r);
603  nrnDelete((number*) &erg, r);
604  return (number)NULL;
605  }
606  // a / gcd(a,b) * [b / gcd (a,b)]^(-1)
607  mpz_ptr tmp = (mpz_ptr)nrnInvers((number) erg,r);
608  mpz_divexact(erg, (mpz_ptr)a, gcd);
609  mpz_mul(erg, erg, tmp);
610  nrnDelete((number*) &gcd, r);
611  nrnDelete((number*) &tmp, r);
612  mpz_mod(erg, erg, r->modNumber);
613  return (number)erg;
614  }
615 }
void WerrorS(const char *s)
Definition: feFopen.cc:24
const char *const nDivBy0
Definition: numbers.h:87
static BOOLEAN nrnIsZero(number a, const coeffs)
Definition: rmodulon.cc:235
static BOOLEAN nrnIsUnit(number a, const coeffs r)
Definition: rmodulon.cc:534
#define nrnDelete
Definition: rmodulon.cc:177
static number nrnInvers(number c, const coeffs r)
Definition: rmodulon.cc:248
static number nrnMult(number a, number b, const coeffs r)
Definition: rmodulon.cc:200
static number nrnGcd(number a, number b, const coeffs r)
Definition: rmodulon.cc:268
int gcd(int a, int b)
Definition: walkSupport.cc:836

◆ nrnDivBy()

static BOOLEAN nrnDivBy ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 556 of file rmodulon.cc.

557 {
558  /* b divides a iff b/gcd(a, b) is a unit in the given ring: */
559  number n = nrnGcd(a, b, r);
560  mpz_tdiv_q((mpz_ptr)n, (mpz_ptr)b, (mpz_ptr)n);
561  bool result = nrnIsUnit(n, r);
562  nrnDelete(&n, NULL);
563  return result;
564 }
return result
Definition: facAbsBiFact.cc:75

◆ nrnDivComp()

static int nrnDivComp ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 566 of file rmodulon.cc.

567 {
568  if (nrnEqual(a, b,r)) return 2;
569  if (mpz_divisible_p((mpz_ptr) a, (mpz_ptr) b)) return -1;
570  if (mpz_divisible_p((mpz_ptr) b, (mpz_ptr) a)) return 1;
571  return 0;
572 }
static BOOLEAN nrnEqual(number a, number b, const coeffs)
Definition: rmodulon.cc:341

◆ nrnEqual()

static BOOLEAN nrnEqual ( number  a,
number  b,
const  coeffs 
)
static

Definition at line 341 of file rmodulon.cc.

342 {
343  return 0 == mpz_cmp((mpz_ptr)a, (mpz_ptr)b);
344 }

◆ nrnExtGcd()

static number nrnExtGcd ( number  a,
number  b,
number *  s,
number *  t,
const coeffs  r 
)
static

Definition at line 320 of file rmodulon.cc.

321 {
322  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
323  mpz_ptr bs = (mpz_ptr)omAllocBin(gmp_nrz_bin);
324  mpz_ptr bt = (mpz_ptr)omAllocBin(gmp_nrz_bin);
325  mpz_init(erg);
326  mpz_init(bs);
327  mpz_init(bt);
328  mpz_gcdext(erg, bs, bt, (mpz_ptr)a, (mpz_ptr)b);
329  mpz_mod(bs, bs, r->modNumber);
330  mpz_mod(bt, bt, r->modNumber);
331  *s = (number)bs;
332  *t = (number)bt;
333  return (number)erg;
334 }

◆ nrnGcd()

static number nrnGcd ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 268 of file rmodulon.cc.

269 {
270  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
271  mpz_init_set(erg, r->modNumber);
272  if (a != NULL) mpz_gcd(erg, erg, (mpz_ptr)a);
273  mpz_gcd(erg, erg, (mpz_ptr)b);
274  if(mpz_cmp(erg,r->modNumber)==0)
275  {
276  mpz_clear(erg);
278  return nrnInit(0,r);
279  }
280  return (number)erg;
281 }
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259

◆ nrnGetUnit()

static number nrnGetUnit ( number  k,
const coeffs  r 
)
static

Definition at line 346 of file rmodulon.cc.

347 {
348  if (mpz_divisible_p(r->modNumber, (mpz_ptr)k)) return nrnInit(1,r);
349 
350  mpz_ptr unit = (mpz_ptr)nrnGcd(NULL, k, r);
351  mpz_tdiv_q(unit, (mpz_ptr)k, unit);
352  mpz_ptr gcd = (mpz_ptr)nrnGcd(NULL, (number)unit, r);
353  if (!nrnIsOne((number)gcd,r))
354  {
355  mpz_ptr ctmp;
356  // tmp := unit^2
357  mpz_ptr tmp = (mpz_ptr) nrnMult((number) unit,(number) unit,r);
358  // gcd_new := gcd(tmp, 0)
359  mpz_ptr gcd_new = (mpz_ptr) nrnGcd(NULL, (number) tmp, r);
360  while (!nrnEqual((number) gcd_new,(number) gcd,r))
361  {
362  // gcd := gcd_new
363  ctmp = gcd;
364  gcd = gcd_new;
365  gcd_new = ctmp;
366  // tmp := tmp * unit
367  mpz_mul(tmp, tmp, unit);
368  mpz_mod(tmp, tmp, r->modNumber);
369  // gcd_new := gcd(tmp, 0)
370  mpz_gcd(gcd_new, tmp, r->modNumber);
371  }
372  // unit := unit + modNumber / gcd_new
373  mpz_tdiv_q(tmp, r->modNumber, gcd_new);
374  mpz_add(unit, unit, tmp);
375  mpz_mod(unit, unit, r->modNumber);
376  nrnDelete((number*) &gcd_new, r);
377  nrnDelete((number*) &tmp, r);
378  }
379  nrnDelete((number*) &gcd, r);
380  return (number)unit;
381 }
static BOOLEAN nrnIsOne(number a, const coeffs)
Definition: rmodulon.cc:336

◆ nrnGreater()

static BOOLEAN nrnGreater ( number  a,
number  b,
const  coeffs 
)
static

Definition at line 493 of file rmodulon.cc.

494 {
495  return 0 < mpz_cmp((mpz_ptr)a, (mpz_ptr)b);
496 }

◆ nrnGreaterZero()

static BOOLEAN nrnGreaterZero ( number  k,
const coeffs  cf 
)
static

Definition at line 498 of file rmodulon.cc.

499 {
500  if (cf->is_field)
501  {
502  if (mpz_cmp_ui(cf->modBase,2)==0)
503  {
504  return TRUE;
505  }
506  #if 0
507  mpz_t ch2; mpz_init_set(ch2, cf->modBase);
508  mpz_sub_ui(ch2,ch2,1); //cf->modBase is odd
509  mpz_divexact_ui(ch2,ch2,2);
510  if (mpz_cmp(ch2,(mpz_ptr)k)<0)
511  {
512  mpz_clear(ch2);
513  return FALSE;
514  }
515  mpz_clear(ch2);
516  #endif
517  }
518  #if 0
519  else
520  {
521  mpz_t ch2; mpz_init_set(ch2, cf->modBase);
522  mpz_tdiv_q_ui(ch2,ch2,2);
523  if (mpz_cmp(ch2,(mpz_ptr)k)<0)
524  {
525  mpz_clear(ch2);
526  return FALSE;
527  }
528  mpz_clear(ch2);
529  }
530  #endif
531  return 0 < mpz_sgn1((mpz_ptr)k);
532 }
CanonicalForm cf
Definition: cfModGcd.cc:4083

◆ nrnInit()

static number nrnInit ( long  i,
const coeffs  r 
)
static

Definition at line 160 of file rmodulon.cc.

161 {
162  mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
163  mpz_init_set_si(erg, i);
164  mpz_mod(erg, erg, r->modNumber);
165  return (number) erg;
166 }

◆ nrnInitCfByName()

coeffs nrnInitCfByName ( char *  s,
n_coeffType  n 
)

Definition at line 35 of file rmodulon.cc.

36 {
37  const char start[]="ZZ/bigint(";
38  const int start_len=strlen(start);
39  if (strncmp(s,start,start_len)==0)
40  {
41  s+=start_len;
42  mpz_t z;
43  mpz_init(z);
44  s=nEatLong(s,z);
45  ZnmInfo info;
46  info.base=z;
47  info.exp= 1;
48  while ((*s!='\0') && (*s!=')')) s++;
49  // expect ")" or ")^exp"
50  if (*s=='\0') { mpz_clear(z); return NULL; }
51  if (((*s)==')') && (*(s+1)=='^'))
52  {
53  s=s+2;
54  int i;
55  s=nEati(s,&i,0);
56  info.exp=(unsigned long)i;
57  return nInitChar(n_Znm,(void*) &info);
58  }
59  else
60  return nInitChar(n_Zn,(void*) &info);
61  }
62  else return NULL;
63 }
@ n_Znm
only used if HAVE_RINGS is defined
Definition: coeffs.h:45
@ n_Zn
only used if HAVE_RINGS is defined
Definition: coeffs.h:44
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:354
char * nEatLong(char *s, mpz_ptr i)
extracts a long integer from s, returns the rest
Definition: numbers.cc:652
char * nEati(char *s, int *i, int m)
divide by the first (leading) number and return it, i.e. make monic
Definition: numbers.cc:631

◆ nrnInitChar()

BOOLEAN nrnInitChar ( coeffs  r,
void *  p 
)

Definition at line 984 of file rmodulon.cc.

985 {
986  assume( (getCoeffType(r) == n_Zn) || (getCoeffType (r) == n_Znm) );
987  ZnmInfo * info= (ZnmInfo *) p;
988  r->modBase= (mpz_ptr)nrnCopy((number)info->base, r); //this circumvents the problem
989  //in bigintmat.cc where we cannot create a "legal" nrn that can be freed.
990  //If we take a copy, we can do whatever we want.
991 
992  nrnInitExp (info->exp, r);
993 
994  /* next computation may yield wrong characteristic as r->modNumber
995  is a GMP number */
996  r->ch = mpz_get_ui(r->modNumber);
997 
998  r->is_field=FALSE;
999  r->is_domain=FALSE;
1000  r->rep=n_rep_gmp;
1001 
1002  r->cfInit = nrnInit;
1003  r->cfDelete = nrnDelete;
1004  r->cfCopy = nrnCopy;
1005  r->cfSize = nrnSize;
1006  r->cfInt = nrnInt;
1007  r->cfAdd = nrnAdd;
1008  r->cfSub = nrnSub;
1009  r->cfMult = nrnMult;
1010  r->cfDiv = nrnDiv;
1011  r->cfAnn = nrnAnn;
1012  r->cfIntMod = nrnMod;
1013  r->cfExactDiv = nrnDiv;
1014  r->cfInpNeg = nrnNeg;
1015  r->cfInvers = nrnInvers;
1016  r->cfDivBy = nrnDivBy;
1017  r->cfDivComp = nrnDivComp;
1018  r->cfGreater = nrnGreater;
1019  r->cfEqual = nrnEqual;
1020  r->cfIsZero = nrnIsZero;
1021  r->cfIsOne = nrnIsOne;
1022  r->cfIsMOne = nrnIsMOne;
1023  r->cfGreaterZero = nrnGreaterZero;
1024  r->cfWriteLong = nrnWrite;
1025  r->cfRead = nrnRead;
1026  r->cfPower = nrnPower;
1027  r->cfSetMap = nrnSetMap;
1028  //r->cfNormalize = ndNormalize;
1029  r->cfLcm = nrnLcm;
1030  r->cfGcd = nrnGcd;
1031  r->cfIsUnit = nrnIsUnit;
1032  r->cfGetUnit = nrnGetUnit;
1033  r->cfExtGcd = nrnExtGcd;
1034  r->cfXExtGcd = nrnXExtGcd;
1035  r->cfQuotRem = nrnQuotRem;
1036  r->cfCoeffName = nrnCoeffName;
1037  r->nCoeffIsEqual = nrnCoeffIsEqual;
1038  r->cfKillChar = nrnKillChar;
1039  r->cfQuot1 = nrnQuot1;
1040  r->cfInitMPZ = nrnInitMPZ;
1041  r->cfMPZ = nrnMPZ;
1042 #if SI_INTEGER_VARIANT==2
1043  r->cfWriteFd = nrzWriteFd;
1044  r->cfReadFd = nrzReadFd;
1045 #endif
1046 
1047 #ifdef LDEBUG
1048  r->cfDBTest = nrnDBTest;
1049 #endif
1050  if ((r->modExponent==1)&&(mpz_size1(r->modBase)==1))
1051  {
1052  long p=mpz_get_si(r->modBase);
1053  if ((p<=FACTORY_MAX_PRIME)&&(p==IsPrime(p))) /*factory limit: <2^29*/
1054  {
1055  r->convFactoryNSingN=nrnConvFactoryNSingN;
1056  r->convSingNFactoryN=nrnConvSingNFactoryN;
1057  }
1058  }
1059  return FALSE;
1060 }
int p
Definition: cfModGcd.cc:4078
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
@ n_rep_gmp
(mpz_ptr), see rmodulon,h
Definition: coeffs.h:115
#define FACTORY_MAX_PRIME
Definition: modulop.h:38
int IsPrime(int p)
Definition: prime.cc:61
number nrzReadFd(const ssiInfo *d, const coeffs)
void nrzWriteFd(number n, const ssiInfo *d, const coeffs)
static const char * nrnRead(const char *s, number *a, const coeffs r)
Definition: rmodulon.cc:946
static coeffs nrnQuot1(number c, const coeffs r)
Definition: rmodulon.cc:105
static void nrnKillChar(coeffs r)
Definition: rmodulon.cc:97
BOOLEAN nrnDBTest(number a, const char *f, const int l, const coeffs r)
Definition: rmodulon.cc:908
#define nrnSize
Definition: rmodulon.cc:178
static BOOLEAN nrnGreater(number a, number b, const coeffs)
Definition: rmodulon.cc:493
static CanonicalForm nrnConvSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: rmodulon.cc:977
static number nrnExtGcd(number a, number b, number *s, number *t, const coeffs r)
Definition: rmodulon.cc:320
static void nrnMPZ(mpz_t m, number &n, const coeffs)
Definition: rmodulon.cc:876
static BOOLEAN nrnCoeffIsEqual(const coeffs r, n_coeffType n, void *parameter)
Definition: rmodulon.cc:89
void nrnWrite(number a, const coeffs)
Definition: rmodulon.cc:770
static number nrnMod(number a, number b, const coeffs r)
Definition: rmodulon.cc:617
static number nrnInitMPZ(mpz_t m, const coeffs r)
Definition: rmodulon.cc:868
static void nrnInitExp(unsigned long m, coeffs r)
Definition: rmodulon.cc:897
static number nrnAnn(number k, const coeffs r)
Definition: rmodulon.cc:542
static char * nrnCoeffName(const coeffs r)
Definition: rmodulon.cc:66
nMapFunc nrnSetMap(const coeffs src, const coeffs dst)
Definition: rmodulon.cc:787
static number nrnConvFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: rmodulon.cc:972
static int nrnDivComp(number a, number b, const coeffs r)
Definition: rmodulon.cc:566
static number nrnXExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: rmodulon.cc:392
static number nrnQuotRem(number a, number b, number *rem, const coeffs r)
Definition: rmodulon.cc:664
static number nrnCopy(number a, const coeffs)
Definition: rmodulon.cc:150
static number nrnSub(number a, number b, const coeffs r)
Definition: rmodulon.cc:226
static number nrnLcm(number a, number b, const coeffs r)
Definition: rmodulon.cc:287
static void nrnPower(number a, int i, number *result, const coeffs r)
Definition: rmodulon.cc:209
static number nrnNeg(number c, const coeffs r)
Definition: rmodulon.cc:240
static number nrnGetUnit(number k, const coeffs r)
Definition: rmodulon.cc:346
static number nrnDiv(number a, number b, const coeffs r)
Definition: rmodulon.cc:574
static BOOLEAN nrnIsMOne(number a, const coeffs r)
Definition: rmodulon.cc:483
static BOOLEAN nrnDivBy(number a, number b, const coeffs r)
Definition: rmodulon.cc:556
static BOOLEAN nrnGreaterZero(number k, const coeffs cf)
Definition: rmodulon.cc:498
static number nrnAdd(number a, number b, const coeffs r)
Definition: rmodulon.cc:217
#define mpz_size1(A)
Definition: si_gmp.h:12

◆ nrnInitExp()

static void nrnInitExp ( unsigned long  m,
coeffs  r 
)
static

Definition at line 897 of file rmodulon.cc.

898 {
899  nrnSetExp(m, r);
900  assume (r->modNumber != NULL);
901 //CF: in general, the modulus is computed somewhere. I don't want to
902 // check it's size before I construct the best ring.
903 // if (mpz_cmp_ui(r->modNumber,2) <= 0)
904 // WarnS("nrnInitExp failed (m in Z/m too small)");
905 }
int m
Definition: cfEzgcd.cc:128
static void nrnSetExp(unsigned long m, coeffs r)
Definition: rmodulon.cc:885

◆ nrnInitMPZ()

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

Definition at line 868 of file rmodulon.cc.

869 {
870  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
871  mpz_init_set(erg,m);
872  mpz_mod(erg, erg, r->modNumber);
873  return (number) erg;
874 }

◆ nrnInt()

static long nrnInt ( number &  n,
const  coeffs 
)
static

Definition at line 171 of file rmodulon.cc.

172 {
173  return mpz_get_si((mpz_ptr) n);
174 }

◆ nrnInvers()

static number nrnInvers ( number  c,
const coeffs  r 
)
static

Definition at line 248 of file rmodulon.cc.

249 {
250  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
251  mpz_init(erg);
252  if (nrnIsZero(c,r))
253  {
254  WerrorS(nDivBy0);
255  }
256  else
257  {
258  mpz_invert(erg, (mpz_ptr)c, r->modNumber);
259  }
260  return (number) erg;
261 }

◆ nrnIsMOne()

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

Definition at line 483 of file rmodulon.cc.

484 {
485  if((r->ch==2) && (nrnIsOne(a,r))) return FALSE;
486  mpz_t t; mpz_init_set(t, (mpz_ptr)a);
487  mpz_add_ui(t, t, 1);
488  bool erg = (0 == mpz_cmp(t, r->modNumber));
489  mpz_clear(t);
490  return erg;
491 }

◆ nrnIsOne()

static BOOLEAN nrnIsOne ( number  a,
const  coeffs 
)
static

Definition at line 336 of file rmodulon.cc.

337 {
338  return 0 == mpz_cmp_si((mpz_ptr)a, 1);
339 }

◆ nrnIsUnit()

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

Definition at line 534 of file rmodulon.cc.

535 {
536  number tmp = nrnGcd(a, (number)r->modNumber, r);
537  bool res = nrnIsOne(tmp, r);
538  nrnDelete(&tmp, r);
539  return res;
540 }
CanonicalForm res
Definition: facAbsFact.cc:60

◆ nrnIsZero()

static BOOLEAN nrnIsZero ( number  a,
const  coeffs 
)
static

Definition at line 235 of file rmodulon.cc.

236 {
237  return 0 == mpz_cmpabs_ui((mpz_ptr)a, 0);
238 }

◆ nrnKillChar()

static void nrnKillChar ( coeffs  r)
static

Definition at line 97 of file rmodulon.cc.

98 {
99  mpz_clear(r->modNumber);
100  mpz_clear(r->modBase);
101  omFreeBin((void *) r->modBase, gmp_nrz_bin);
102  omFreeBin((void *) r->modNumber, gmp_nrz_bin);
103 }

◆ nrnLcm()

static number nrnLcm ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 287 of file rmodulon.cc.

288 {
289  number erg = nrnGcd(NULL, a, r);
290  number tmp = nrnGcd(NULL, b, r);
291  mpz_lcm((mpz_ptr)erg, (mpz_ptr)erg, (mpz_ptr)tmp);
292  nrnDelete(&tmp, r);
293  return (number)erg;
294 }

◆ nrnMap2toM()

static number nrnMap2toM ( number  from,
const  coeffs,
const coeffs  dst 
)
static

Definition at line 707 of file rmodulon.cc.

708 {
709  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
710  mpz_init(erg);
711  mpz_mul_ui(erg, nrnMapCoef, (unsigned long)from);
712  mpz_mod(erg, erg, dst->modNumber);
713  return (number)erg;
714 }
STATIC_VAR mpz_ptr nrnMapCoef
Definition: rmodulon.cc:700

◆ nrnMapGMP()

number nrnMapGMP ( number  from,
const  coeffs,
const coeffs  dst 
)

Definition at line 726 of file rmodulon.cc.

727 {
728  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
729  mpz_init(erg);
730  mpz_mod(erg, (mpz_ptr)from, dst->modNumber);
731  return (number)erg;
732 }

◆ nrnMapModN()

static number nrnMapModN ( number  from,
const  coeffs,
const coeffs  dst 
)
static

Definition at line 702 of file rmodulon.cc.

703 {
704  return nrnMult(from, (number) nrnMapCoef, dst);
705 }

◆ nrnMapQ()

static number nrnMapQ ( number  from,
const coeffs  src,
const coeffs  dst 
)
static

Definition at line 734 of file rmodulon.cc.

735 {
736  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
737  nlMPZ(erg, from, src);
738  mpz_mod(erg, erg, dst->modNumber);
739  return (number)erg;
740 }
void nlMPZ(mpz_t m, number &n, const coeffs r)
Definition: longrat.cc:2819

◆ nrnMapZ()

static number nrnMapZ ( number  from,
const coeffs  src,
const coeffs  dst 
)
static

Definition at line 755 of file rmodulon.cc.

756 {
757  if (SR_HDL(from) & SR_INT)
758  {
759  long f_i=SR_TO_INT(from);
760  return nrnInit(f_i,dst);
761  }
762  return nrnMapGMP(from,src,dst);
763 }
#define SR_INT
Definition: longrat.h:67
#define SR_TO_INT(SR)
Definition: longrat.h:69
number nrnMapGMP(number from, const coeffs, const coeffs dst)
Definition: rmodulon.cc:726
#define SR_HDL(A)
Definition: tgb.cc:35

◆ nrnMapZp()

static number nrnMapZp ( number  from,
const  coeffs,
const coeffs  dst 
)
static

Definition at line 716 of file rmodulon.cc.

717 {
718  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
719  mpz_init(erg);
720  // TODO: use npInt(...)
721  mpz_mul_si(erg, nrnMapCoef, (unsigned long)from);
722  mpz_mod(erg, erg, dst->modNumber);
723  return (number)erg;
724 }
void mpz_mul_si(mpz_ptr r, mpz_srcptr s, long int si)
Definition: longrat.cc:177

◆ nrnMod()

static number nrnMod ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 617 of file rmodulon.cc.

618 {
619  /*
620  We need to return the number rr which is uniquely determined by the
621  following two properties:
622  (1) 0 <= rr < |b| (with respect to '<' and '<=' performed in Z x Z)
623  (2) There exists some k in the integers Z such that a = k * b + rr.
624  Consider g := gcd(n, |b|). Note that then |b|/g is a unit in Z/n.
625  Now, there are three cases:
626  (a) g = 1
627  Then |b| is a unit in Z/n, i.e. |b| (and also b) divides a.
628  Thus rr = 0.
629  (b) g <> 1 and g divides a
630  Then a = (a/g) * (|b|/g)^(-1) * b (up to sign), i.e. again rr = 0.
631  (c) g <> 1 and g does not divide a
632  Then denote the division with remainder of a by g as this:
633  a = s * g + t. Then t = a - s * g = a - s * (|b|/g)^(-1) * |b|
634  fulfills (1) and (2), i.e. rr := t is the correct result. Hence
635  in this third case, rr is the remainder of division of a by g in Z.
636  Remark: according to mpz_mod: a,b are always non-negative
637  */
638  mpz_ptr g = (mpz_ptr)omAllocBin(gmp_nrz_bin);
639  mpz_ptr rr = (mpz_ptr)omAllocBin(gmp_nrz_bin);
640  mpz_init(g);
641  mpz_init_set_ui(rr, 0);
642  mpz_gcd(g, (mpz_ptr)r->modNumber, (mpz_ptr)b); // g is now as above
643  if (mpz_cmp_si(g, 1L) != 0) mpz_mod(rr, (mpz_ptr)a, g); // the case g <> 1
644  mpz_clear(g);
646  return (number)rr;
647 }
g
Definition: cfModGcd.cc:4090

◆ nrnMPZ()

static void nrnMPZ ( mpz_t  m,
number &  n,
const  coeffs 
)
static

Definition at line 876 of file rmodulon.cc.

877 {
878  mpz_init_set(m, (mpz_ptr)n);
879 }

◆ nrnMult()

static number nrnMult ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 200 of file rmodulon.cc.

201 {
202  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
203  mpz_init(erg);
204  mpz_mul(erg, (mpz_ptr)a, (mpz_ptr) b);
205  mpz_mod(erg, erg, r->modNumber);
206  return (number) erg;
207 }

◆ nrnNeg()

static number nrnNeg ( number  c,
const coeffs  r 
)
static

Definition at line 240 of file rmodulon.cc.

241 {
242  if( !nrnIsZero(c, r) )
243  // Attention: This method operates in-place.
244  mpz_sub((mpz_ptr)c, r->modNumber, (mpz_ptr)c);
245  return c;
246 }

◆ nrnPower()

static void nrnPower ( number  a,
int  i,
number *  result,
const coeffs  r 
)
static

Definition at line 209 of file rmodulon.cc.

210 {
211  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
212  mpz_init(erg);
213  mpz_powm_ui(erg, (mpz_ptr)a, i, r->modNumber);
214  *result = (number) erg;
215 }

◆ nrnQuot1()

static coeffs nrnQuot1 ( number  c,
const coeffs  r 
)
static

Definition at line 105 of file rmodulon.cc.

106 {
107  coeffs rr;
108  long ch = r->cfInt(c, r);
109  mpz_t a,b;
110  mpz_init_set(a, r->modNumber);
111  mpz_init_set_ui(b, ch);
112  mpz_t gcd;
113  mpz_init(gcd);
114  mpz_gcd(gcd, a,b);
115  if(mpz_cmp_ui(gcd, 1) == 0)
116  {
117  WerrorS("constant in q-ideal is coprime to modulus in ground ring");
118  WerrorS("Unable to create qring!");
119  return NULL;
120  }
121  if(r->modExponent == 1)
122  {
123  ZnmInfo info;
124  info.base = gcd;
125  info.exp = (unsigned long) 1;
126  rr = nInitChar(n_Zn, (void*)&info);
127  }
128  else
129  {
130  ZnmInfo info;
131  info.base = r->modBase;
132  int kNew = 1;
133  mpz_t baseTokNew;
134  mpz_init(baseTokNew);
135  mpz_set(baseTokNew, r->modBase);
136  while(mpz_cmp(gcd, baseTokNew) > 0)
137  {
138  kNew++;
139  mpz_mul(baseTokNew, baseTokNew, r->modBase);
140  }
141  //printf("\nkNew = %i\n",kNew);
142  info.exp = kNew;
143  mpz_clear(baseTokNew);
144  rr = nInitChar(n_Znm, (void*)&info);
145  }
146  mpz_clear(gcd);
147  return(rr);
148 }
The main handler for Singular numbers which are suitable for Singular polynomials.

◆ nrnQuotRem()

static number nrnQuotRem ( number  a,
number  b,
number *  rem,
const coeffs  r 
)
static

Definition at line 664 of file rmodulon.cc.

665 {
666  mpz_t g, aa, bb;
667  mpz_ptr qq = (mpz_ptr)omAllocBin(gmp_nrz_bin);
668  mpz_ptr rr = (mpz_ptr)omAllocBin(gmp_nrz_bin);
669  mpz_init(qq);
670  mpz_init(rr);
671  mpz_init(g);
672  mpz_init_set(aa, (mpz_ptr)a);
673  mpz_init_set(bb, (mpz_ptr)b);
674 
675  mpz_gcd(g, bb, r->modNumber);
676  mpz_mod(rr, aa, g);
677  mpz_sub(aa, aa, rr);
678  mpz_gcd(g, aa, g);
679  mpz_div(aa, aa, g);
680  mpz_div(bb, bb, g);
681  mpz_div(g, r->modNumber, g);
682  mpz_invert(g, bb, g);
683  mpz_mul(qq, aa, g);
684  if (rem)
685  *rem = (number)rr;
686  else {
687  mpz_clear(rr);
688  omFreeBin(rr, gmp_nrz_bin);
689  }
690  mpz_clear(g);
691  mpz_clear(aa);
692  mpz_clear(bb);
693  return (number) qq;
694 }
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition: minpoly.cc:572

◆ nrnRead()

static const char* nrnRead ( const char *  s,
number *  a,
const coeffs  r 
)
static

Definition at line 946 of file rmodulon.cc.

947 {
948  mpz_ptr z = (mpz_ptr) omAllocBin(gmp_nrz_bin);
949  {
950  s = nlCPEatLongC((char *)s, z);
951  }
952  mpz_mod(z, z, r->modNumber);
953  if ((*s)=='/')
954  {
955  mpz_ptr n = (mpz_ptr) omAllocBin(gmp_nrz_bin);
956  s++;
957  s=nlCPEatLongC((char*)s,n);
958  if (!nrnIsOne((number)n,r))
959  {
960  *a=nrnDiv((number)z,(number)n,r);
961  mpz_clear(z);
962  omFreeBin((void *)z, gmp_nrz_bin);
963  mpz_clear(n);
964  omFreeBin((void *)n, gmp_nrz_bin);
965  }
966  }
967  else
968  *a = (number) z;
969  return s;
970 }
static const char * nlCPEatLongC(char *s, mpz_ptr i)
Definition: rmodulon.cc:922

◆ nrnSetExp()

static void nrnSetExp ( unsigned long  m,
coeffs  r 
)
static

Definition at line 885 of file rmodulon.cc.

886 {
887  /* clean up former stuff */
888  if (r->modNumber != NULL) mpz_clear(r->modNumber);
889 
890  r->modExponent= m;
891  r->modNumber = (mpz_ptr)omAllocBin(gmp_nrz_bin);
892  mpz_init_set (r->modNumber, r->modBase);
893  mpz_pow_ui (r->modNumber, r->modNumber, m);
894 }

◆ nrnSetMap()

nMapFunc nrnSetMap ( const coeffs  src,
const coeffs  dst 
)

Definition at line 787 of file rmodulon.cc.

788 {
789  /* dst = nrn */
790  if ((src->rep==n_rep_gmp) && nCoeff_is_Z(src))
791  {
792  return nrnMapZ;
793  }
794  if ((src->rep==n_rep_gap_gmp) /*&& nCoeff_is_Z(src)*/)
795  {
796  return nrnMapZ;
797  }
798  if (src->rep==n_rep_gap_rat) /*&& nCoeff_is_Q(src)) or Z*/
799  {
800  return nrnMapQ;
801  }
802  // Some type of Z/n ring / field
803  if (nCoeff_is_Zn(src) || nCoeff_is_Ring_PtoM(src) ||
804  nCoeff_is_Ring_2toM(src) || nCoeff_is_Zp(src))
805  {
806  if ( (!nCoeff_is_Zp(src))
807  && (mpz_cmp(src->modBase, dst->modBase) == 0)
808  && (src->modExponent == dst->modExponent)) return ndCopyMap;
809  else
810  {
811  mpz_ptr nrnMapModul = (mpz_ptr) omAllocBin(gmp_nrz_bin);
812  // Computing the n of Z/n
813  if (nCoeff_is_Zp(src))
814  {
815  mpz_init_set_si(nrnMapModul, src->ch);
816  }
817  else
818  {
819  mpz_init(nrnMapModul);
820  mpz_set(nrnMapModul, src->modNumber);
821  }
822  // nrnMapCoef = 1 in dst if dst is a subring of src
823  // nrnMapCoef = 0 in dst / src if src is a subring of dst
824  if (nrnMapCoef == NULL)
825  {
826  nrnMapCoef = (mpz_ptr) omAllocBin(gmp_nrz_bin);
827  mpz_init(nrnMapCoef);
828  }
829  if (mpz_divisible_p(nrnMapModul, dst->modNumber))
830  {
831  mpz_set_ui(nrnMapCoef, 1);
832  }
833  else
834  if (mpz_divisible_p(dst->modNumber,nrnMapModul))
835  {
836  mpz_divexact(nrnMapCoef, dst->modNumber, nrnMapModul);
837  mpz_ptr tmp = dst->modNumber;
838  dst->modNumber = nrnMapModul;
839  if (!nrnIsUnit((number) nrnMapCoef,dst))
840  {
841  dst->modNumber = tmp;
842  nrnDelete((number*) &nrnMapModul, dst);
843  return NULL;
844  }
845  mpz_ptr inv = (mpz_ptr) nrnInvers((number) nrnMapCoef,dst);
846  dst->modNumber = tmp;
847  mpz_mul(nrnMapCoef, nrnMapCoef, inv);
848  mpz_mod(nrnMapCoef, nrnMapCoef, dst->modNumber);
849  nrnDelete((number*) &inv, dst);
850  }
851  else
852  {
853  nrnDelete((number*) &nrnMapModul, dst);
854  return NULL;
855  }
856  nrnDelete((number*) &nrnMapModul, dst);
857  if (nCoeff_is_Ring_2toM(src))
858  return nrnMap2toM;
859  else if (nCoeff_is_Zp(src))
860  return nrnMapZp;
861  else
862  return nrnMapModN;
863  }
864  }
865  return NULL; // default
866 }
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:816
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition: numbers.cc:255
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:800
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:724
@ n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:111
@ n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition: coeffs.h:112
static number nrnMap2toM(number from, const coeffs, const coeffs dst)
Definition: rmodulon.cc:707
static number nrnMapZ(number from, const coeffs src, const coeffs dst)
Definition: rmodulon.cc:755
static number nrnMapZp(number from, const coeffs, const coeffs dst)
Definition: rmodulon.cc:716
static number nrnMapQ(number from, const coeffs src, const coeffs dst)
Definition: rmodulon.cc:734
static number nrnMapModN(number from, const coeffs, const coeffs dst)
Definition: rmodulon.cc:702

◆ nrnSub()

static number nrnSub ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 226 of file rmodulon.cc.

227 {
228  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
229  mpz_init(erg);
230  mpz_sub(erg, (mpz_ptr)a, (mpz_ptr) b);
231  mpz_mod(erg, erg, r->modNumber);
232  return (number) erg;
233 }

◆ nrnWrite()

void nrnWrite ( number  a,
const  coeffs 
)

Definition at line 770 of file rmodulon.cc.

771 {
772  char *s,*z;
773  if (a==NULL)
774  {
775  StringAppendS("o");
776  }
777  else
778  {
779  int l=mpz_sizeinbase((mpz_ptr) a, 10) + 2;
780  s=(char*)omAlloc(l);
781  z=mpz_get_str(s,10,(mpz_ptr) a);
782  StringAppendS(z);
783  omFreeSize((ADDRESS)s,l);
784  }
785 }
void StringAppendS(const char *st)
Definition: reporter.cc:107

◆ nrnXExtGcd()

static number nrnXExtGcd ( number  a,
number  b,
number *  s,
number *  t,
number *  u,
number *  v,
const coeffs  r 
)
static

Definition at line 392 of file rmodulon.cc.

393 {
394  number xx;
395 #ifdef CF_DEB
396  StringSetS("XExtGcd of ");
397  nrnWrite(a, r);
398  StringAppendS("\t");
399  nrnWrite(b, r);
400  StringAppendS(" modulo ");
401  nrnWrite(xx = (number)r->modNumber, r);
402  Print("%s\n", StringEndS());
403 #endif
404 
405  mpz_ptr one = (mpz_ptr)omAllocBin(gmp_nrz_bin);
406  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
407  mpz_ptr bs = (mpz_ptr)omAllocBin(gmp_nrz_bin);
408  mpz_ptr bt = (mpz_ptr)omAllocBin(gmp_nrz_bin);
409  mpz_ptr bu = (mpz_ptr)omAllocBin(gmp_nrz_bin);
410  mpz_ptr bv = (mpz_ptr)omAllocBin(gmp_nrz_bin);
411  mpz_init(erg);
412  mpz_init(one);
413  mpz_init_set(bs, (mpz_ptr) a);
414  mpz_init_set(bt, (mpz_ptr) b);
415  mpz_init(bu);
416  mpz_init(bv);
417  mpz_gcd(erg, bs, bt);
418 
419 #ifdef CF_DEB
420  StringSetS("1st gcd:");
421  nrnWrite(xx= (number)erg, r);
422 #endif
423 
424  mpz_gcd(erg, erg, r->modNumber);
425 
426  mpz_div(bs, bs, erg);
427  mpz_div(bt, bt, erg);
428 
429 #ifdef CF_DEB
430  Print("%s\n", StringEndS());
431  StringSetS("xgcd: ");
432 #endif
433 
434  mpz_gcdext(one, bu, bv, bs, bt);
435  number ui = nrnGetUnit(xx = (number) one, r);
436 #ifdef CF_DEB
437  n_Write(xx, r);
438  StringAppendS("\t");
439  n_Write(ui, r);
440  Print("%s\n", StringEndS());
441 #endif
442  nrnDelete(&xx, r);
443  if (!nrnIsOne(ui, r))
444  {
445 #ifdef CF_DEB
446  PrintS("Scaling\n");
447 #endif
448  number uii = nrnInvers(ui, r);
449  nrnDelete(&ui, r);
450  ui = uii;
451  mpz_ptr uu = (mpz_ptr)omAllocBin(gmp_nrz_bin);
452  mpz_init_set(uu, (mpz_ptr)ui);
453  mpz_mul(bu, bu, uu);
454  mpz_mul(bv, bv, uu);
455  mpz_clear(uu);
456  omFreeBin(uu, gmp_nrz_bin);
457  }
458  nrnDelete(&ui, r);
459 #ifdef CF_DEB
460  StringSetS("xgcd");
461  nrnWrite(xx= (number)bs, r);
462  StringAppendS("*");
463  nrnWrite(xx= (number)bu, r);
464  StringAppendS(" + ");
465  nrnWrite(xx= (number)bt, r);
466  StringAppendS("*");
467  nrnWrite(xx= (number)bv, r);
468  Print("%s\n", StringEndS());
469 #endif
470 
471  mpz_mod(bs, bs, r->modNumber);
472  mpz_mod(bt, bt, r->modNumber);
473  mpz_mod(bu, bu, r->modNumber);
474  mpz_mod(bv, bv, r->modNumber);
475  *s = (number)bu;
476  *t = (number)bv;
477  *u = (number)bt;
478  *u = nrnNeg(*u, r);
479  *v = (number)bs;
480  return (number)erg;
481 }
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 Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
void StringSetS(const char *st)
Definition: reporter.cc:128
void PrintS(const char *s)
Definition: reporter.cc:284
char * StringEndS()
Definition: reporter.cc:151

Variable Documentation

◆ gmp_nrz_bin

EXTERN_VAR omBin gmp_nrz_bin

Definition at line 33 of file rmodulon.cc.

◆ nrnCoeffName_buff

STATIC_VAR char* nrnCoeffName_buff =NULL

Definition at line 65 of file rmodulon.cc.

◆ nrnMapCoef

STATIC_VAR mpz_ptr nrnMapCoef = NULL

Definition at line 700 of file rmodulon.cc.