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 nrnInpMult (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 void nrnInpAdd (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 934 of file rmodulon.cc.

935 {
936  const char * start=s;
937  if (!(*s >= '0' && *s <= '9'))
938  {
939  mpz_init_set_ui(i, 1);
940  return s;
941  }
942  mpz_init(i);
943  while (*s >= '0' && *s <= '9') s++;
944  if (*s=='\0')
945  {
946  mpz_set_str(i,start,10);
947  }
948  else
949  {
950  char c=*s;
951  *s='\0';
952  mpz_set_str(i,start,10);
953  *s=c;
954  }
955  return s;
956 }
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 223 of file rmodulon.cc.

224 {
225  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
226  mpz_init(erg);
227  mpz_add(erg, (mpz_ptr)a, (mpz_ptr) b);
228  mpz_mod(erg, erg, r->modNumber);
229  return (number) erg;
230 }
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 554 of file rmodulon.cc.

555 {
556  mpz_ptr tmp = (mpz_ptr) omAllocBin(gmp_nrz_bin);
557  mpz_init(tmp);
558  mpz_gcd(tmp, (mpz_ptr) k, r->modNumber);
559  if (mpz_cmp_si(tmp, 1)==0)
560  {
561  mpz_set_ui(tmp, 0);
562  return (number) tmp;
563  }
564  mpz_divexact(tmp, r->modNumber, tmp);
565  return (number) tmp;
566 }
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:389
#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 984 of file rmodulon.cc.

985 {
986  return nrnInit(n.intval(),r);
987 }
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 989 of file rmodulon.cc.

990 {
991  if (setChar) setCharacteristic( r->ch );
992  return CanonicalForm(nrnInt( n,r ));
993 }
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 920 of file rmodulon.cc.

921 {
922  if ( (mpz_sgn1((mpz_ptr) a) < 0) || (mpz_cmp((mpz_ptr) a, r->modNumber) > 0) )
923  {
924  Warn("mod-n: out of range at %s:%d\n",f,l);
925  return FALSE;
926  }
927  return TRUE;
928 }
#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:18

◆ nrnDiv()

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

Definition at line 586 of file rmodulon.cc.

587 {
588  if (nrnIsZero(b,r))
589  {
590  WerrorS(nDivBy0);
591  return nrnInit(0,r);
592  }
593  else if (r->is_field)
594  {
595  number inv=nrnInvers(b,r);
596  number erg=nrnMult(a,inv,r);
597  nrnDelete(&inv,r);
598  return erg;
599  }
600  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
601  mpz_init(erg);
602  if (mpz_divisible_p((mpz_ptr)a, (mpz_ptr)b))
603  {
604  mpz_divexact(erg, (mpz_ptr)a, (mpz_ptr)b);
605  return (number)erg;
606  }
607  else
608  {
609  mpz_ptr gcd = (mpz_ptr)nrnGcd(a, b, r);
610  mpz_divexact(erg, (mpz_ptr)b, gcd);
611  if (!nrnIsUnit((number)erg, r))
612  {
613  WerrorS("Division not possible, even by cancelling zero divisors.");
614  nrnDelete((number*) &gcd, r);
615  nrnDelete((number*) &erg, r);
616  return (number)NULL;
617  }
618  // a / gcd(a,b) * [b / gcd (a,b)]^(-1)
619  mpz_ptr tmp = (mpz_ptr)nrnInvers((number) erg,r);
620  mpz_divexact(erg, (mpz_ptr)a, gcd);
621  mpz_mul(erg, erg, tmp);
622  nrnDelete((number*) &gcd, r);
623  nrnDelete((number*) &tmp, r);
624  mpz_mod(erg, erg, r->modNumber);
625  return (number)erg;
626  }
627 }
void WerrorS(const char *s)
Definition: feFopen.cc:24
const char *const nDivBy0
Definition: numbers.h:88
static BOOLEAN nrnIsZero(number a, const coeffs)
Definition: rmodulon.cc:247
static BOOLEAN nrnIsUnit(number a, const coeffs r)
Definition: rmodulon.cc:546
#define nrnDelete
Definition: rmodulon.cc:177
static number nrnInvers(number c, const coeffs r)
Definition: rmodulon.cc:260
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:280
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 568 of file rmodulon.cc.

569 {
570  /* b divides a iff b/gcd(a, b) is a unit in the given ring: */
571  number n = nrnGcd(a, b, r);
572  mpz_tdiv_q((mpz_ptr)n, (mpz_ptr)b, (mpz_ptr)n);
573  bool result = nrnIsUnit(n, r);
574  nrnDelete(&n, NULL);
575  return result;
576 }
return result
Definition: facAbsBiFact.cc:75

◆ nrnDivComp()

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

Definition at line 578 of file rmodulon.cc.

579 {
580  if (nrnEqual(a, b,r)) return 2;
581  if (mpz_divisible_p((mpz_ptr) a, (mpz_ptr) b)) return -1;
582  if (mpz_divisible_p((mpz_ptr) b, (mpz_ptr) a)) return 1;
583  return 0;
584 }
static BOOLEAN nrnEqual(number a, number b, const coeffs)
Definition: rmodulon.cc:353

◆ nrnEqual()

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

Definition at line 353 of file rmodulon.cc.

354 {
355  return 0 == mpz_cmp((mpz_ptr)a, (mpz_ptr)b);
356 }

◆ nrnExtGcd()

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

Definition at line 332 of file rmodulon.cc.

333 {
334  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
335  mpz_ptr bs = (mpz_ptr)omAllocBin(gmp_nrz_bin);
336  mpz_ptr bt = (mpz_ptr)omAllocBin(gmp_nrz_bin);
337  mpz_init(erg);
338  mpz_init(bs);
339  mpz_init(bt);
340  mpz_gcdext(erg, bs, bt, (mpz_ptr)a, (mpz_ptr)b);
341  mpz_mod(bs, bs, r->modNumber);
342  mpz_mod(bt, bt, r->modNumber);
343  *s = (number)bs;
344  *t = (number)bt;
345  return (number)erg;
346 }

◆ nrnGcd()

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

Definition at line 280 of file rmodulon.cc.

281 {
282  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
283  mpz_init_set(erg, r->modNumber);
284  if (a != NULL) mpz_gcd(erg, erg, (mpz_ptr)a);
285  mpz_gcd(erg, erg, (mpz_ptr)b);
286  if(mpz_cmp(erg,r->modNumber)==0)
287  {
288  mpz_clear(erg);
290  return nrnInit(0,r);
291  }
292  return (number)erg;
293 }
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259

◆ nrnGetUnit()

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

Definition at line 358 of file rmodulon.cc.

359 {
360  if (mpz_divisible_p(r->modNumber, (mpz_ptr)k)) return nrnInit(1,r);
361 
362  mpz_ptr unit = (mpz_ptr)nrnGcd(NULL, k, r);
363  mpz_tdiv_q(unit, (mpz_ptr)k, unit);
364  mpz_ptr gcd = (mpz_ptr)nrnGcd(NULL, (number)unit, r);
365  if (!nrnIsOne((number)gcd,r))
366  {
367  mpz_ptr ctmp;
368  // tmp := unit^2
369  mpz_ptr tmp = (mpz_ptr) nrnMult((number) unit,(number) unit,r);
370  // gcd_new := gcd(tmp, 0)
371  mpz_ptr gcd_new = (mpz_ptr) nrnGcd(NULL, (number) tmp, r);
372  while (!nrnEqual((number) gcd_new,(number) gcd,r))
373  {
374  // gcd := gcd_new
375  ctmp = gcd;
376  gcd = gcd_new;
377  gcd_new = ctmp;
378  // tmp := tmp * unit
379  mpz_mul(tmp, tmp, unit);
380  mpz_mod(tmp, tmp, r->modNumber);
381  // gcd_new := gcd(tmp, 0)
382  mpz_gcd(gcd_new, tmp, r->modNumber);
383  }
384  // unit := unit + modNumber / gcd_new
385  mpz_tdiv_q(tmp, r->modNumber, gcd_new);
386  mpz_add(unit, unit, tmp);
387  mpz_mod(unit, unit, r->modNumber);
388  nrnDelete((number*) &gcd_new, r);
389  nrnDelete((number*) &tmp, r);
390  }
391  nrnDelete((number*) &gcd, r);
392  return (number)unit;
393 }
static BOOLEAN nrnIsOne(number a, const coeffs)
Definition: rmodulon.cc:348

◆ nrnGreater()

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

Definition at line 505 of file rmodulon.cc.

506 {
507  return 0 < mpz_cmp((mpz_ptr)a, (mpz_ptr)b);
508 }

◆ nrnGreaterZero()

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

Definition at line 510 of file rmodulon.cc.

511 {
512  if (cf->is_field)
513  {
514  if (mpz_cmp_ui(cf->modBase,2)==0)
515  {
516  return TRUE;
517  }
518  #if 0
519  mpz_t ch2; mpz_init_set(ch2, cf->modBase);
520  mpz_sub_ui(ch2,ch2,1); //cf->modBase is odd
521  mpz_divexact_ui(ch2,ch2,2);
522  if (mpz_cmp(ch2,(mpz_ptr)k)<0)
523  {
524  mpz_clear(ch2);
525  return FALSE;
526  }
527  mpz_clear(ch2);
528  #endif
529  }
530  #if 0
531  else
532  {
533  mpz_t ch2; mpz_init_set(ch2, cf->modBase);
534  mpz_tdiv_q_ui(ch2,ch2,2);
535  if (mpz_cmp(ch2,(mpz_ptr)k)<0)
536  {
537  mpz_clear(ch2);
538  return FALSE;
539  }
540  mpz_clear(ch2);
541  }
542  #endif
543  return 0 < mpz_sgn1((mpz_ptr)k);
544 }
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:392
char * nEatLong(char *s, mpz_ptr i)
extracts a long integer from s, returns the rest
Definition: numbers.cc:677
char * nEati(char *s, int *i, int m)
divide by the first (leading) number and return it, i.e. make monic
Definition: numbers.cc:656

◆ nrnInitChar()

BOOLEAN nrnInitChar ( coeffs  r,
void *  p 
)

Definition at line 996 of file rmodulon.cc.

997 {
998  assume( (getCoeffType(r) == n_Zn) || (getCoeffType (r) == n_Znm) );
999  ZnmInfo * info= (ZnmInfo *) p;
1000  r->modBase= (mpz_ptr)nrnCopy((number)info->base, r); //this circumvents the problem
1001  //in bigintmat.cc where we cannot create a "legal" nrn that can be freed.
1002  //If we take a copy, we can do whatever we want.
1003 
1004  nrnInitExp (info->exp, r);
1005 
1006  /* next computation may yield wrong characteristic as r->modNumber
1007  is a GMP number */
1008  r->ch = mpz_get_ui(r->modNumber);
1009 
1010  r->is_field=FALSE;
1011  r->is_domain=FALSE;
1012  r->rep=n_rep_gmp;
1013 
1014  r->cfInit = nrnInit;
1015  r->cfDelete = nrnDelete;
1016  r->cfCopy = nrnCopy;
1017  r->cfSize = nrnSize;
1018  r->cfInt = nrnInt;
1019  r->cfAdd = nrnAdd;
1020  r->cfInpAdd = nrnInpAdd;
1021  r->cfSub = nrnSub;
1022  r->cfMult = nrnMult;
1023  r->cfInpMult = nrnInpMult;
1024  r->cfDiv = nrnDiv;
1025  r->cfAnn = nrnAnn;
1026  r->cfIntMod = nrnMod;
1027  r->cfExactDiv = nrnDiv;
1028  r->cfInpNeg = nrnNeg;
1029  r->cfInvers = nrnInvers;
1030  r->cfDivBy = nrnDivBy;
1031  r->cfDivComp = nrnDivComp;
1032  r->cfGreater = nrnGreater;
1033  r->cfEqual = nrnEqual;
1034  r->cfIsZero = nrnIsZero;
1035  r->cfIsOne = nrnIsOne;
1036  r->cfIsMOne = nrnIsMOne;
1037  r->cfGreaterZero = nrnGreaterZero;
1038  r->cfWriteLong = nrnWrite;
1039  r->cfRead = nrnRead;
1040  r->cfPower = nrnPower;
1041  r->cfSetMap = nrnSetMap;
1042  //r->cfNormalize = ndNormalize;
1043  r->cfLcm = nrnLcm;
1044  r->cfGcd = nrnGcd;
1045  r->cfIsUnit = nrnIsUnit;
1046  r->cfGetUnit = nrnGetUnit;
1047  r->cfExtGcd = nrnExtGcd;
1048  r->cfXExtGcd = nrnXExtGcd;
1049  r->cfQuotRem = nrnQuotRem;
1050  r->cfCoeffName = nrnCoeffName;
1051  r->nCoeffIsEqual = nrnCoeffIsEqual;
1052  r->cfKillChar = nrnKillChar;
1053  r->cfQuot1 = nrnQuot1;
1054  r->cfInitMPZ = nrnInitMPZ;
1055  r->cfMPZ = nrnMPZ;
1056 #if SI_INTEGER_VARIANT==2
1057  r->cfWriteFd = nrzWriteFd;
1058  r->cfReadFd = nrzReadFd;
1059 #endif
1060 
1061 #ifdef LDEBUG
1062  r->cfDBTest = nrnDBTest;
1063 #endif
1064  if ((r->modExponent==1)&&(mpz_size1(r->modBase)==1))
1065  {
1066  long p=mpz_get_si(r->modBase);
1067  if ((p<=FACTORY_MAX_PRIME)&&(p==IsPrime(p))) /*factory limit: <2^29*/
1068  {
1069  r->convFactoryNSingN=nrnConvFactoryNSingN;
1070  r->convSingNFactoryN=nrnConvSingNFactoryN;
1071  }
1072  }
1073  return FALSE;
1074 }
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:958
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:920
#define nrnSize
Definition: rmodulon.cc:178
static BOOLEAN nrnGreater(number a, number b, const coeffs)
Definition: rmodulon.cc:505
static CanonicalForm nrnConvSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: rmodulon.cc:989
static number nrnExtGcd(number a, number b, number *s, number *t, const coeffs r)
Definition: rmodulon.cc:332
static void nrnMPZ(mpz_t m, number &n, const coeffs)
Definition: rmodulon.cc:888
static BOOLEAN nrnCoeffIsEqual(const coeffs r, n_coeffType n, void *parameter)
Definition: rmodulon.cc:89
static void nrnInpMult(number &a, number b, const coeffs r)
Definition: rmodulon.cc:209
void nrnWrite(number a, const coeffs)
Definition: rmodulon.cc:782
static number nrnMod(number a, number b, const coeffs r)
Definition: rmodulon.cc:629
static number nrnInitMPZ(mpz_t m, const coeffs r)
Definition: rmodulon.cc:880
static void nrnInitExp(unsigned long m, coeffs r)
Definition: rmodulon.cc:909
static number nrnAnn(number k, const coeffs r)
Definition: rmodulon.cc:554
static char * nrnCoeffName(const coeffs r)
Definition: rmodulon.cc:66
nMapFunc nrnSetMap(const coeffs src, const coeffs dst)
Definition: rmodulon.cc:799
static number nrnConvFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: rmodulon.cc:984
static int nrnDivComp(number a, number b, const coeffs r)
Definition: rmodulon.cc:578
static number nrnXExtGcd(number a, number b, number *s, number *t, number *u, number *v, const coeffs r)
Definition: rmodulon.cc:404
static number nrnQuotRem(number a, number b, number *rem, const coeffs r)
Definition: rmodulon.cc:676
static number nrnCopy(number a, const coeffs)
Definition: rmodulon.cc:150
static number nrnSub(number a, number b, const coeffs r)
Definition: rmodulon.cc:238
static number nrnLcm(number a, number b, const coeffs r)
Definition: rmodulon.cc:299
static void nrnPower(number a, int i, number *result, const coeffs r)
Definition: rmodulon.cc:215
static number nrnNeg(number c, const coeffs r)
Definition: rmodulon.cc:252
static number nrnGetUnit(number k, const coeffs r)
Definition: rmodulon.cc:358
static number nrnDiv(number a, number b, const coeffs r)
Definition: rmodulon.cc:586
static BOOLEAN nrnIsMOne(number a, const coeffs r)
Definition: rmodulon.cc:495
static BOOLEAN nrnDivBy(number a, number b, const coeffs r)
Definition: rmodulon.cc:568
static BOOLEAN nrnGreaterZero(number k, const coeffs cf)
Definition: rmodulon.cc:510
static number nrnAdd(number a, number b, const coeffs r)
Definition: rmodulon.cc:223
static void nrnInpAdd(number &a, number b, const coeffs r)
Definition: rmodulon.cc:232
#define mpz_size1(A)
Definition: si_gmp.h:17

◆ nrnInitExp()

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

Definition at line 909 of file rmodulon.cc.

910 {
911  nrnSetExp(m, r);
912  assume (r->modNumber != NULL);
913 //CF: in general, the modulus is computed somewhere. I don't want to
914 // check it's size before I construct the best ring.
915 // if (mpz_cmp_ui(r->modNumber,2) <= 0)
916 // WarnS("nrnInitExp failed (m in Z/m too small)");
917 }
int m
Definition: cfEzgcd.cc:128
static void nrnSetExp(unsigned long m, coeffs r)
Definition: rmodulon.cc:897

◆ nrnInitMPZ()

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

Definition at line 880 of file rmodulon.cc.

881 {
882  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
883  mpz_init_set(erg,m);
884  mpz_mod(erg, erg, r->modNumber);
885  return (number) erg;
886 }

◆ nrnInpAdd()

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

Definition at line 232 of file rmodulon.cc.

233 {
234  mpz_add((mpz_ptr)a, (mpz_ptr)a, (mpz_ptr) b);
235  mpz_mod((mpz_ptr)a, (mpz_ptr)a, r->modNumber);
236 }

◆ nrnInpMult()

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

Definition at line 209 of file rmodulon.cc.

210 {
211  mpz_mul((mpz_ptr)a, (mpz_ptr)a, (mpz_ptr) b);
212  mpz_mod((mpz_ptr)a, (mpz_ptr)a, r->modNumber);
213 }

◆ 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 260 of file rmodulon.cc.

261 {
262  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
263  mpz_init(erg);
264  if (nrnIsZero(c,r))
265  {
266  WerrorS(nDivBy0);
267  }
268  else
269  {
270  mpz_invert(erg, (mpz_ptr)c, r->modNumber);
271  }
272  return (number) erg;
273 }

◆ nrnIsMOne()

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

Definition at line 495 of file rmodulon.cc.

496 {
497  if((r->ch==2) && (nrnIsOne(a,r))) return FALSE;
498  mpz_t t; mpz_init_set(t, (mpz_ptr)a);
499  mpz_add_ui(t, t, 1);
500  bool erg = (0 == mpz_cmp(t, r->modNumber));
501  mpz_clear(t);
502  return erg;
503 }

◆ nrnIsOne()

static BOOLEAN nrnIsOne ( number  a,
const  coeffs 
)
static

Definition at line 348 of file rmodulon.cc.

349 {
350  return 0 == mpz_cmp_si((mpz_ptr)a, 1);
351 }

◆ nrnIsUnit()

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

Definition at line 546 of file rmodulon.cc.

547 {
548  number tmp = nrnGcd(a, (number)r->modNumber, r);
549  bool res = nrnIsOne(tmp, r);
550  nrnDelete(&tmp, r);
551  return res;
552 }
CanonicalForm res
Definition: facAbsFact.cc:60

◆ nrnIsZero()

static BOOLEAN nrnIsZero ( number  a,
const  coeffs 
)
static

Definition at line 247 of file rmodulon.cc.

248 {
249  return 0 == mpz_cmpabs_ui((mpz_ptr)a, 0);
250 }

◆ 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 299 of file rmodulon.cc.

300 {
301  number erg = nrnGcd(NULL, a, r);
302  number tmp = nrnGcd(NULL, b, r);
303  mpz_lcm((mpz_ptr)erg, (mpz_ptr)erg, (mpz_ptr)tmp);
304  nrnDelete(&tmp, r);
305  return (number)erg;
306 }

◆ nrnMap2toM()

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

Definition at line 719 of file rmodulon.cc.

720 {
721  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
722  mpz_init(erg);
723  mpz_mul_ui(erg, nrnMapCoef, (unsigned long)from);
724  mpz_mod(erg, erg, dst->modNumber);
725  return (number)erg;
726 }
STATIC_VAR mpz_ptr nrnMapCoef
Definition: rmodulon.cc:712

◆ nrnMapGMP()

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

Definition at line 738 of file rmodulon.cc.

739 {
740  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
741  mpz_init(erg);
742  mpz_mod(erg, (mpz_ptr)from, dst->modNumber);
743  return (number)erg;
744 }

◆ nrnMapModN()

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

Definition at line 714 of file rmodulon.cc.

715 {
716  return nrnMult(from, (number) nrnMapCoef, dst);
717 }

◆ nrnMapQ()

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

Definition at line 746 of file rmodulon.cc.

747 {
748  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
749  nlMPZ(erg, from, src);
750  mpz_mod(erg, erg, dst->modNumber);
751  return (number)erg;
752 }
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 767 of file rmodulon.cc.

768 {
769  if (SR_HDL(from) & SR_INT)
770  {
771  long f_i=SR_TO_INT(from);
772  return nrnInit(f_i,dst);
773  }
774  return nrnMapGMP(from,src,dst);
775 }
#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:738
#define SR_HDL(A)
Definition: tgb.cc:35

◆ nrnMapZp()

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

Definition at line 728 of file rmodulon.cc.

729 {
730  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
731  mpz_init(erg);
732  // TODO: use npInt(...)
733  mpz_mul_si(erg, nrnMapCoef, (unsigned long)from);
734  mpz_mod(erg, erg, dst->modNumber);
735  return (number)erg;
736 }
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 629 of file rmodulon.cc.

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

◆ nrnMPZ()

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

Definition at line 888 of file rmodulon.cc.

889 {
890  mpz_init_set(m, (mpz_ptr)n);
891 }

◆ 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 252 of file rmodulon.cc.

253 {
254  if( !nrnIsZero(c, r) )
255  // Attention: This method operates in-place.
256  mpz_sub((mpz_ptr)c, r->modNumber, (mpz_ptr)c);
257  return c;
258 }

◆ nrnPower()

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

Definition at line 215 of file rmodulon.cc.

216 {
217  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
218  mpz_init(erg);
219  mpz_powm_ui(erg, (mpz_ptr)a, i, r->modNumber);
220  *result = (number) erg;
221 }

◆ 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 676 of file rmodulon.cc.

677 {
678  mpz_t g, aa, bb;
679  mpz_ptr qq = (mpz_ptr)omAllocBin(gmp_nrz_bin);
680  mpz_ptr rr = (mpz_ptr)omAllocBin(gmp_nrz_bin);
681  mpz_init(qq);
682  mpz_init(rr);
683  mpz_init(g);
684  mpz_init_set(aa, (mpz_ptr)a);
685  mpz_init_set(bb, (mpz_ptr)b);
686 
687  mpz_gcd(g, bb, r->modNumber);
688  mpz_mod(rr, aa, g);
689  mpz_sub(aa, aa, rr);
690  mpz_gcd(g, aa, g);
691  mpz_div(aa, aa, g);
692  mpz_div(bb, bb, g);
693  mpz_div(g, r->modNumber, g);
694  mpz_invert(g, bb, g);
695  mpz_mul(qq, aa, g);
696  if (rem)
697  *rem = (number)rr;
698  else {
699  mpz_clear(rr);
700  omFreeBin(rr, gmp_nrz_bin);
701  }
702  mpz_clear(g);
703  mpz_clear(aa);
704  mpz_clear(bb);
705  return (number) qq;
706 }
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 958 of file rmodulon.cc.

959 {
960  mpz_ptr z = (mpz_ptr) omAllocBin(gmp_nrz_bin);
961  {
962  s = nlCPEatLongC((char *)s, z);
963  }
964  mpz_mod(z, z, r->modNumber);
965  if ((*s)=='/')
966  {
967  mpz_ptr n = (mpz_ptr) omAllocBin(gmp_nrz_bin);
968  s++;
969  s=nlCPEatLongC((char*)s,n);
970  if (!nrnIsOne((number)n,r))
971  {
972  *a=nrnDiv((number)z,(number)n,r);
973  mpz_clear(z);
974  omFreeBin((void *)z, gmp_nrz_bin);
975  mpz_clear(n);
976  omFreeBin((void *)n, gmp_nrz_bin);
977  }
978  }
979  else
980  *a = (number) z;
981  return s;
982 }
static const char * nlCPEatLongC(char *s, mpz_ptr i)
Definition: rmodulon.cc:934

◆ nrnSetExp()

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

Definition at line 897 of file rmodulon.cc.

898 {
899  /* clean up former stuff */
900  if (r->modNumber != NULL) mpz_clear(r->modNumber);
901 
902  r->modExponent= m;
903  r->modNumber = (mpz_ptr)omAllocBin(gmp_nrz_bin);
904  mpz_init_set (r->modNumber, r->modBase);
905  mpz_pow_ui (r->modNumber, r->modNumber, m);
906 }

◆ nrnSetMap()

nMapFunc nrnSetMap ( const coeffs  src,
const coeffs  dst 
)

Definition at line 799 of file rmodulon.cc.

800 {
801  /* dst = nrn */
802  if ((src->rep==n_rep_gmp) && nCoeff_is_Z(src))
803  {
804  return nrnMapZ;
805  }
806  if ((src->rep==n_rep_gap_gmp) /*&& nCoeff_is_Z(src)*/)
807  {
808  return nrnMapZ;
809  }
810  if (src->rep==n_rep_gap_rat) /*&& nCoeff_is_Q(src)) or Z*/
811  {
812  return nrnMapQ;
813  }
814  // Some type of Z/n ring / field
815  if (nCoeff_is_Zn(src) || nCoeff_is_Ring_PtoM(src) ||
816  nCoeff_is_Ring_2toM(src) || nCoeff_is_Zp(src))
817  {
818  if ( (!nCoeff_is_Zp(src))
819  && (mpz_cmp(src->modBase, dst->modBase) == 0)
820  && (src->modExponent == dst->modExponent)) return ndCopyMap;
821  else
822  {
823  mpz_ptr nrnMapModul = (mpz_ptr) omAllocBin(gmp_nrz_bin);
824  // Computing the n of Z/n
825  if (nCoeff_is_Zp(src))
826  {
827  mpz_init_set_si(nrnMapModul, src->ch);
828  }
829  else
830  {
831  mpz_init(nrnMapModul);
832  mpz_set(nrnMapModul, src->modNumber);
833  }
834  // nrnMapCoef = 1 in dst if dst is a subring of src
835  // nrnMapCoef = 0 in dst / src if src is a subring of dst
836  if (nrnMapCoef == NULL)
837  {
838  nrnMapCoef = (mpz_ptr) omAllocBin(gmp_nrz_bin);
839  mpz_init(nrnMapCoef);
840  }
841  if (mpz_divisible_p(nrnMapModul, dst->modNumber))
842  {
843  mpz_set_ui(nrnMapCoef, 1);
844  }
845  else
846  if (mpz_divisible_p(dst->modNumber,nrnMapModul))
847  {
848  mpz_divexact(nrnMapCoef, dst->modNumber, nrnMapModul);
849  mpz_ptr tmp = dst->modNumber;
850  dst->modNumber = nrnMapModul;
851  if (!nrnIsUnit((number) nrnMapCoef,dst))
852  {
853  dst->modNumber = tmp;
854  nrnDelete((number*) &nrnMapModul, dst);
855  return NULL;
856  }
857  mpz_ptr inv = (mpz_ptr) nrnInvers((number) nrnMapCoef,dst);
858  dst->modNumber = tmp;
859  mpz_mul(nrnMapCoef, nrnMapCoef, inv);
860  mpz_mod(nrnMapCoef, nrnMapCoef, dst->modNumber);
861  nrnDelete((number*) &inv, dst);
862  }
863  else
864  {
865  nrnDelete((number*) &nrnMapModul, dst);
866  return NULL;
867  }
868  nrnDelete((number*) &nrnMapModul, dst);
869  if (nCoeff_is_Ring_2toM(src))
870  return nrnMap2toM;
871  else if (nCoeff_is_Zp(src))
872  return nrnMapZp;
873  else
874  return nrnMapModN;
875  }
876  }
877  return NULL; // default
878 }
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:282
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:719
static number nrnMapZ(number from, const coeffs src, const coeffs dst)
Definition: rmodulon.cc:767
static number nrnMapZp(number from, const coeffs, const coeffs dst)
Definition: rmodulon.cc:728
static number nrnMapQ(number from, const coeffs src, const coeffs dst)
Definition: rmodulon.cc:746
static number nrnMapModN(number from, const coeffs, const coeffs dst)
Definition: rmodulon.cc:714

◆ nrnSub()

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

Definition at line 238 of file rmodulon.cc.

239 {
240  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
241  mpz_init(erg);
242  mpz_sub(erg, (mpz_ptr)a, (mpz_ptr) b);
243  mpz_mod(erg, erg, r->modNumber);
244  return (number) erg;
245 }

◆ nrnWrite()

void nrnWrite ( number  a,
const  coeffs 
)

Definition at line 782 of file rmodulon.cc.

783 {
784  char *s,*z;
785  if (a==NULL)
786  {
787  StringAppendS("o");
788  }
789  else
790  {
791  int l=mpz_sizeinbase((mpz_ptr) a, 10) + 2;
792  s=(char*)omAlloc(l);
793  z=mpz_get_str(s,10,(mpz_ptr) a);
794  StringAppendS(z);
795  omFreeSize((ADDRESS)s,l);
796  }
797 }
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 404 of file rmodulon.cc.

405 {
406  number xx;
407 #ifdef CF_DEB
408  StringSetS("XExtGcd of ");
409  nrnWrite(a, r);
410  StringAppendS("\t");
411  nrnWrite(b, r);
412  StringAppendS(" modulo ");
413  nrnWrite(xx = (number)r->modNumber, r);
414  Print("%s\n", StringEndS());
415 #endif
416 
417  mpz_ptr one = (mpz_ptr)omAllocBin(gmp_nrz_bin);
418  mpz_ptr erg = (mpz_ptr)omAllocBin(gmp_nrz_bin);
419  mpz_ptr bs = (mpz_ptr)omAllocBin(gmp_nrz_bin);
420  mpz_ptr bt = (mpz_ptr)omAllocBin(gmp_nrz_bin);
421  mpz_ptr bu = (mpz_ptr)omAllocBin(gmp_nrz_bin);
422  mpz_ptr bv = (mpz_ptr)omAllocBin(gmp_nrz_bin);
423  mpz_init(erg);
424  mpz_init(one);
425  mpz_init_set(bs, (mpz_ptr) a);
426  mpz_init_set(bt, (mpz_ptr) b);
427  mpz_init(bu);
428  mpz_init(bv);
429  mpz_gcd(erg, bs, bt);
430 
431 #ifdef CF_DEB
432  StringSetS("1st gcd:");
433  nrnWrite(xx= (number)erg, r);
434 #endif
435 
436  mpz_gcd(erg, erg, r->modNumber);
437 
438  mpz_div(bs, bs, erg);
439  mpz_div(bt, bt, erg);
440 
441 #ifdef CF_DEB
442  Print("%s\n", StringEndS());
443  StringSetS("xgcd: ");
444 #endif
445 
446  mpz_gcdext(one, bu, bv, bs, bt);
447  number ui = nrnGetUnit(xx = (number) one, r);
448 #ifdef CF_DEB
449  n_Write(xx, r);
450  StringAppendS("\t");
451  n_Write(ui, r);
452  Print("%s\n", StringEndS());
453 #endif
454  nrnDelete(&xx, r);
455  if (!nrnIsOne(ui, r))
456  {
457 #ifdef CF_DEB
458  PrintS("Scaling\n");
459 #endif
460  number uii = nrnInvers(ui, r);
461  nrnDelete(&ui, r);
462  ui = uii;
463  mpz_ptr uu = (mpz_ptr)omAllocBin(gmp_nrz_bin);
464  mpz_init_set(uu, (mpz_ptr)ui);
465  mpz_mul(bu, bu, uu);
466  mpz_mul(bv, bv, uu);
467  mpz_clear(uu);
468  omFreeBin(uu, gmp_nrz_bin);
469  }
470  nrnDelete(&ui, r);
471 #ifdef CF_DEB
472  StringSetS("xgcd");
473  nrnWrite(xx= (number)bs, r);
474  StringAppendS("*");
475  nrnWrite(xx= (number)bu, r);
476  StringAppendS(" + ");
477  nrnWrite(xx= (number)bt, r);
478  StringAppendS("*");
479  nrnWrite(xx= (number)bv, r);
480  Print("%s\n", StringEndS());
481 #endif
482 
483  mpz_mod(bs, bs, r->modNumber);
484  mpz_mod(bt, bt, r->modNumber);
485  mpz_mod(bu, bu, r->modNumber);
486  mpz_mod(bv, bv, r->modNumber);
487  *s = (number)bu;
488  *t = (number)bv;
489  *u = (number)bt;
490  *u = nrnNeg(*u, r);
491  *v = (number)bs;
492  return (number)erg;
493 }
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 712 of file rmodulon.cc.