My Project
Functions
modulop.cc File Reference
#include "misc/auxiliary.h"
#include "factory/factory.h"
#include "misc/mylimits.h"
#include "misc/sirandom.h"
#include "reporter/reporter.h"
#include "coeffs/coeffs.h"
#include "coeffs/numbers.h"
#include "coeffs/mpr_complex.h"
#include "coeffs/longrat.h"
#include "coeffs/modulop.h"
#include <string.h>
#include "coeffs/modulop_inl.h"

Go to the source code of this file.

Functions

static BOOLEAN npGreaterZero (number k, const coeffs r)
 
static BOOLEAN npIsMOne (number a, const coeffs r)
 
static number npDiv (number a, number b, const coeffs r)
 
static number npNeg (number c, const coeffs r)
 
static number npInvers (number c, const coeffs r)
 
static BOOLEAN npGreater (number a, number b, const coeffs r)
 
static BOOLEAN npEqual (number a, number b, const coeffs r)
 
static void npWrite (number a, const coeffs r)
 
static const char * npRead (const char *s, number *a, const coeffs r)
 
static void nvInpMult (number &a, number b, const coeffs r)
 
static BOOLEAN npDBTest (number a, const char *f, const int l, const coeffs r)
 
static nMapFunc npSetMap (const coeffs src, const coeffs dst)
 
static number nvDiv (number a, number b, const coeffs r)
 
number nvInvers (number c, const coeffs r)
 
void npInpMult (number &a, number b, const coeffs r)
 
long npInt (number &n, const coeffs r)
 
static const char * npEati (const char *s, int *i, const coeffs r)
 
void npKillChar (coeffs r)
 
static BOOLEAN npCoeffsEqual (const coeffs r, n_coeffType n, void *parameter)
 
CanonicalForm npConvSingNFactoryN (number n, BOOLEAN setChar, const coeffs r)
 
number npConvFactoryNSingN (const CanonicalForm n, const coeffs r)
 
static char * npCoeffName (const coeffs cf)
 
static void npWriteFd (number n, const ssiInfo *d, const coeffs)
 
static number npReadFd (const ssiInfo *d, const coeffs)
 
static number npRandom (siRandProc p, number, number, const coeffs cf)
 
static number npPar (int, coeffs r)
 
static number npInitMPZ (mpz_t m, const coeffs r)
 
BOOLEAN npInitChar (coeffs r, void *p)
 
static number npMapP (number from, const coeffs src, const coeffs dst_r)
 
static number npMapLongR (number from, const coeffs, const coeffs dst_r)
 
static number npMapGMP (number from, const coeffs, const coeffs dst)
 
static number npMapZ (number from, const coeffs src, const coeffs dst)
 
static number npMapMachineInt (number from, const coeffs, const coeffs dst)
 
static number npMapCanonicalForm (number a, const coeffs, const coeffs dst)
 
static number nvInversM (number c, const coeffs r)
 

Function Documentation

◆ npCoeffName()

static char* npCoeffName ( const coeffs  cf)
static

Definition at line 300 of file modulop.cc.

301 {
302  STATIC_VAR char npCoeffName_buf[15];
303  snprintf(npCoeffName_buf,14,"ZZ/%d",cf->ch);
304  return npCoeffName_buf;
305 }
CanonicalForm cf
Definition: cfModGcd.cc:4083
#define STATIC_VAR
Definition: globaldefs.h:7

◆ npCoeffsEqual()

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

Definition at line 276 of file modulop.cc.

277 {
278  /* test, if r is an instance of nInitCoeffs(n,parameter) */
279  return (n==n_Zp) && (r->ch==(int)(long)parameter);
280 }
@ n_Zp
\F{p < 2^31}
Definition: coeffs.h:29

◆ npConvFactoryNSingN()

number npConvFactoryNSingN ( const CanonicalForm  n,
const coeffs  r 
)

Definition at line 287 of file modulop.cc.

288 {
289  if (n.isImm())
290  {
291  return npInit(n.intval(),r);
292  }
293  else
294  {
295  assume(0);
296  return NULL;
297  }
298 }
long intval() const
conversion functions
bool isImm() const
#define assume(x)
Definition: mod2.h:389
static number npInit(long i, const coeffs r)
Definition: modulop_inl.h:27
#define NULL
Definition: omList.c:12

◆ npConvSingNFactoryN()

CanonicalForm npConvSingNFactoryN ( number  n,
BOOLEAN  setChar,
const coeffs  r 
)

Definition at line 281 of file modulop.cc.

282 {
283  if (setChar) setCharacteristic( r->ch );
284  return CanonicalForm(npInt( n,r ));
285 }
void FACTORY_PUBLIC setCharacteristic(int c)
Definition: cf_char.cc:28
factory's main class
Definition: canonicalform.h:86
long npInt(number &n, const coeffs r)
Definition: modulop.cc:83

◆ npDBTest()

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

Definition at line 476 of file modulop.cc.

477 {
478  if (((long)a<0L) || ((long)a>(long)r->ch))
479  {
480  Print("wrong mod p number %ld at %s,%d\n",(long)a,f,l);
481  return FALSE;
482  }
483  return TRUE;
484 }
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
int l
Definition: cfEzgcd.cc:100
FILE * f
Definition: checklibs.c:9
#define Print
Definition: emacs.cc:80

◆ npDiv()

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

Definition at line 98 of file modulop.cc.

99 {
100  n_Test(a, r);
101  n_Test(b, r);
102 
103  if ((long)b==0L)
104  {
105  WerrorS(nDivBy0);
106  return (number)0L;
107  }
108  if ((long)a==0) return (number)0L;
109 
110  number d;
111 #ifndef HAVE_GENERIC_MULT
112  int s = r->npLogTable[(long)a] - r->npLogTable[(long)b];
113  #ifdef HAVE_GENERIC_ADD
114  if (s < 0)
115  s += r->npPminus1M;
116  #else
117  #if SIZEOF_LONG == 8
118  s += ((long)s >> 63) & r->npPminus1M;
119  #else
120  s += ((long)s >> 31) & r->npPminus1M;
121  #endif
122  #endif
123  d = (number)(long)r->npExpTable[s];
124 #else
125  number inv=npInversM(b,r);
126  d = npMultM(a,inv,r);
127 #endif
128 
129  n_Test(d, r);
130  return d;
131 
132 }
CanonicalForm b
Definition: cfModGcd.cc:4103
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:709
const CanonicalForm int s
Definition: facAbsFact.cc:51
void WerrorS(const char *s)
Definition: feFopen.cc:24
static number npMultM(number a, number b, const coeffs r)
Definition: modulop.h:71
static number npInversM(number c, const coeffs r)
Definition: modulop.h:223
const char *const nDivBy0
Definition: numbers.h:89

◆ npEati()

static const char* npEati ( const char *  s,
int *  i,
const coeffs  r 
)
inlinestatic

Definition at line 214 of file modulop.cc.

215 {
216  return nEati((char *)s,i,(int)r->ch);
217 }
int i
Definition: cfEzgcd.cc:132
char * nEati(char *s, int *i, int m)
divide by the first (leading) number and return it, i.e. make monic
Definition: numbers.cc:677

◆ npEqual()

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

Definition at line 174 of file modulop.cc.

175 {
176  n_Test(a, r);
177  n_Test(b, r);
178 
179 // return (long)a == (long)b;
180 
181  return npEqualM(a,b,r);
182 }
#define npEqualM(A, B, r)
Definition: modulop.h:259

◆ npGreater()

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

Definition at line 165 of file modulop.cc.

166 {
167  n_Test(a, r);
168  n_Test(b, r);
169 
170  //return (long)a != (long)b;
171  return ((long)a) > ((long)b);
172 }

◆ npGreaterZero()

static BOOLEAN npGreaterZero ( number  k,
const coeffs  r 
)
static

Definition at line 51 of file modulop.cc.

52 {
53  n_Test(k, r);
54 
55  int h = (int)((long) k);
56  return ((int)h !=0) && (h <= (r->ch>>1));
57 }
int k
Definition: cfEzgcd.cc:99
STATIC_VAR Poly * h
Definition: janet.cc:971

◆ npInitChar()

BOOLEAN npInitChar ( coeffs  r,
void *  p 
)

Definition at line 338 of file modulop.cc.

339 {
340  assume( getCoeffType(r) == n_Zp );
341  const int c = (int) (long) p;
342 
343  assume( c > 0 );
344 
345  int i, w;
346 
347  r->is_field=TRUE;
348  r->is_domain=TRUE;
349  r->rep=n_rep_int;
350 
351  r->ch = c;
352  r->npPminus1M = c /*r->ch*/ - 1;
353 
354  //r->cfInitChar=npInitChar;
355  r->cfKillChar=npKillChar;
356  r->nCoeffIsEqual=npCoeffsEqual;
357  r->cfCoeffName=npCoeffName;
358 
359  r->cfMult = npMult;
360  r->cfInpMult = npInpMult;
361  r->cfSub = npSubM;
362  r->cfAdd = npAddM;
363  r->cfInpAdd = npInpAddM;
364  r->cfDiv = npDiv;
365  r->cfInit = npInit;
366  //r->cfSize = ndSize;
367  r->cfInt = npInt;
368  r->cfInitMPZ = npInitMPZ;
369  #ifdef HAVE_RINGS
370  //r->cfDivComp = NULL; // only for ring stuff
371  //r->cfIsUnit = NULL; // only for ring stuff
372  //r->cfGetUnit = NULL; // only for ring stuff
373  //r->cfExtGcd = NULL; // only for ring stuff
374  // r->cfDivBy = NULL; // only for ring stuff
375  #endif
376  r->cfInpNeg = npNeg;
377  r->cfInvers= npInvers;
378  //r->cfCopy = ndCopy;
379  //r->cfRePart = ndCopy;
380  //r->cfImPart = ndReturn0;
381  r->cfWriteLong = npWrite;
382  r->cfRead = npRead;
383  //r->cfNormalize=ndNormalize;
384  r->cfGreater = npGreater;
385  r->cfEqual = npEqual;
386  r->cfIsZero = npIsZero;
387  r->cfIsOne = npIsOne;
388  r->cfIsMOne = npIsMOne;
389  r->cfGreaterZero = npGreaterZero;
390  //r->cfPower = npPower;
391  //r->cfGetDenom = ndGetDenom;
392  //r->cfGetNumerator = ndGetNumerator;
393  //r->cfGcd = ndGcd;
394  //r->cfLcm = ndGcd;
395  //r->cfDelete= ndDelete;
396  r->cfSetMap = npSetMap;
397  //r->cfName = ndName;
398  //r->cfInpMult=ndInpMult;
399  r->convSingNFactoryN=npConvSingNFactoryN;
400  r->convFactoryNSingN=npConvFactoryNSingN;
401  r->cfRandom=npRandom;
402 #ifdef LDEBUG
403  // debug stuff
404  r->cfDBTest=npDBTest;
405 #endif
406 
407  // io via ssi
408  r->cfWriteFd=npWriteFd;
409  r->cfReadFd=npReadFd;
410 
411  // the variables:
412  r->type = n_Zp;
413  r->has_simple_Alloc=TRUE;
414  r->has_simple_Inverse=TRUE;
415 
416  // the tables
417 #ifdef NV_OPS
418  if (r->ch <=NV_MAX_PRIME)
419 #endif
420  {
421 #ifdef HAVE_INVTABLE
422  r->npInvTable=(unsigned short*)omAlloc0( r->ch*sizeof(unsigned short) );
423 #endif
424 #ifndef HAVE_GENERIC_MULT
425  r->cfParameter=npPar; /* Singular.jl */
426  r->npExpTable=(unsigned short *)omAlloc0( r->ch*sizeof(unsigned short) );
427  r->npLogTable=(unsigned short *)omAlloc0( r->ch*sizeof(unsigned short) );
428  r->npExpTable[0] = 1;
429  r->npLogTable[0] = 0;
430  if (r->ch > 2)
431  {
432  w = 1;
433  loop
434  {
435  r->npLogTable[1] = 0;
436  w++;
437  i = 0;
438  loop
439  {
440  i++;
441  r->npExpTable[i] =(int)(((long)w * (long)r->npExpTable[i-1]) % r->ch);
442  r->npLogTable[r->npExpTable[i]] = i;
443  if /*(i == r->ch - 1 ) ||*/ (/*(*/ r->npExpTable[i] == 1 /*)*/)
444  break;
445  }
446  if (i == r->ch - 1)
447  break;
448  }
449  }
450  else
451  {
452  r->npExpTable[1] = 1;
453  r->npLogTable[1] = 0;
454  }
455 #endif
456  }
457 #ifdef NV_OPS
458  else /*if (c>NV_MAX_PRIME)*/
459  {
460  r->cfMult = nvMult;
461  r->cfDiv = nvDiv;
462  r->cfExactDiv = nvDiv;
463  r->cfInvers = nvInvers;
464  r->cfInpMult = nvInpMult;
465  //r->cfPower= nvPower;
466  //if (c>FACTORY_MAX_PRIME) // factory will catch this error
467  //{
468  // r->convSingNFactoryN=ndConvSingNFactoryN;
469  //}
470  }
471 #endif
472  return FALSE;
473 }
int p
Definition: cfModGcd.cc:4078
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
@ n_rep_int
(int), see modulop.h
Definition: coeffs.h:110
const CanonicalForm & w
Definition: facAbsFact.cc:51
static BOOLEAN npCoeffsEqual(const coeffs r, n_coeffType n, void *parameter)
Definition: modulop.cc:276
static const char * npRead(const char *s, number *a, const coeffs r)
Definition: modulop.cc:219
static number npInitMPZ(mpz_t m, const coeffs r)
Definition: modulop.cc:333
static void npWrite(number a, const coeffs r)
Definition: modulop.cc:184
CanonicalForm npConvSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: modulop.cc:281
static void npWriteFd(number n, const ssiInfo *d, const coeffs)
Definition: modulop.cc:307
static number nvDiv(number a, number b, const coeffs r)
Definition: modulop.cc:658
static number npDiv(number a, number b, const coeffs r)
Definition: modulop.cc:98
number nvInvers(number c, const coeffs r)
Definition: modulop.cc:673
static number npPar(int, coeffs r)
Definition: modulop.cc:327
static number npInvers(number c, const coeffs r)
Definition: modulop.cc:133
static BOOLEAN npEqual(number a, number b, const coeffs r)
Definition: modulop.cc:174
static number npNeg(number c, const coeffs r)
Definition: modulop.cc:148
static BOOLEAN npGreater(number a, number b, const coeffs r)
Definition: modulop.cc:165
static char * npCoeffName(const coeffs cf)
Definition: modulop.cc:300
void npInpMult(number &a, number b, const coeffs r)
Definition: modulop.cc:68
static BOOLEAN npIsMOne(number a, const coeffs r)
Definition: modulop.cc:91
static BOOLEAN npGreaterZero(number k, const coeffs r)
Definition: modulop.cc:51
static BOOLEAN npDBTest(number a, const char *f, const int l, const coeffs r)
Definition: modulop.cc:476
static nMapFunc npSetMap(const coeffs src, const coeffs dst)
Definition: modulop.cc:607
static number npReadFd(const ssiInfo *d, const coeffs)
Definition: modulop.cc:312
static void nvInpMult(number &a, number b, const coeffs r)
Definition: modulop.cc:646
static number npRandom(siRandProc p, number, number, const coeffs cf)
Definition: modulop.cc:320
void npKillChar(coeffs r)
Definition: modulop.cc:257
number npConvFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: modulop.cc:287
static BOOLEAN npIsOne(number a, const coeffs)
Definition: modulop.h:179
static number npAddM(number a, number b, const coeffs r)
Definition: modulop.h:124
#define NV_MAX_PRIME
Definition: modulop.h:37
static void npInpAddM(number &a, number b, const coeffs r)
Definition: modulop.h:129
static number npSubM(number a, number b, const coeffs r)
Definition: modulop.h:134
static number nvMult(number a, number b, const coeffs r)
Definition: modulop_inl.h:50
static number npMult(number a, number b, const coeffs r)
Definition: modulop_inl.h:12
static BOOLEAN npIsZero(number a, const coeffs r)
Definition: modulop_inl.h:38
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#define loop
Definition: structs.h:75

◆ npInitMPZ()

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

Definition at line 333 of file modulop.cc.

334 {
335  return (number)mpz_fdiv_ui(m, r->ch);
336 }
int m
Definition: cfEzgcd.cc:128

◆ npInpMult()

void npInpMult ( number &  a,
number  b,
const coeffs  r 
)

Definition at line 68 of file modulop.cc.

69 {
70  n_Test(a, r);
71  n_Test(b, r);
72 
73  if (((long)a == 0) || ((long)b == 0))
74  a=(number)0;
75  else
76  a = npMultM(a,b, r);
77  n_Test(a, r);
78 }

◆ npInt()

long npInt ( number &  n,
const coeffs  r 
)

Definition at line 83 of file modulop.cc.

84 {
85  n_Test(n, r);
86 
87  if ((long)n > (((long)r->ch) >>1)) return ((long)n -((long)r->ch));
88  else return ((long)n);
89 }

◆ npInvers()

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

Definition at line 133 of file modulop.cc.

134 {
135  n_Test(c, r);
136 
137  if ((long)c==0L)
138  {
139  WerrorS("1/0");
140  return (number)0L;
141  }
142  number d = npInversM(c,r);
143 
144  n_Test(d, r);
145  return d;
146 }

◆ npIsMOne()

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

Definition at line 91 of file modulop.cc.

92 {
93  n_Test(a, r);
94 
95  return ((r->npPminus1M == (long)a) &&(1L!=(long)a))/*for char 2*/;
96 }

◆ npKillChar()

void npKillChar ( coeffs  r)

Definition at line 257 of file modulop.cc.

258 {
259  #ifdef HAVE_INVTABLE
260  if (r->npInvTable!=NULL)
261  {
262  omFreeSize( (void *)r->npInvTable, r->ch*sizeof(unsigned short) );
263  r->npInvTable=NULL;
264  }
265  #endif
266  #ifndef HAVE_GENERIC_MULT
267  if (r->npExpTable!=NULL)
268  {
269  omFreeSize( (void *)r->npExpTable, r->ch*sizeof(unsigned short) );
270  omFreeSize( (void *)r->npLogTable, r->ch*sizeof(unsigned short) );
271  r->npExpTable=NULL; r->npLogTable=NULL;
272  }
273  #endif
274 }
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260

◆ npMapCanonicalForm()

static number npMapCanonicalForm ( number  a,
const  coeffs,
const coeffs  dst 
)
static

Definition at line 600 of file modulop.cc.

601 {
602  setCharacteristic (dst ->ch);
604  return (number) (f.intval());
605 }
virtual class for internal CanonicalForm's
Definition: int_cf.h:47

◆ npMapGMP()

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

Definition at line 575 of file modulop.cc.

576 {
577  return (number)mpz_fdiv_ui((mpz_ptr) from, dst->ch);
578 }

◆ npMapLongR()

static number npMapLongR ( number  from,
const  coeffs,
const coeffs  dst_r 
)
static

Definition at line 499 of file modulop.cc.

500 {
501  gmp_float *ff=(gmp_float*)from;
502  mpf_t *f=ff->_mpfp();
503  number res;
504  mpz_ptr dest,ndest;
505  int size,i;
506  int e,al,bl;
507  long iz;
508  mp_ptr qp,dd,nn;
509 
510  size = (*f)[0]._mp_size;
511  if (size == 0)
512  return npInit(0,dst_r);
513  if(size<0)
514  size = -size;
515 
516  qp = (*f)[0]._mp_d;
517  while(qp[0]==0)
518  {
519  qp++;
520  size--;
521  }
522 
523  if(dst_r->ch>2)
524  e=(*f)[0]._mp_exp-size;
525  else
526  e=0;
527  res = ALLOC_RNUMBER();
528 #if defined(LDEBUG)
529  res->debug=123456;
530 #endif
531  dest = res->z;
532 
533  long in=0;
534  if (e<0)
535  {
536  al = dest->_mp_size = size;
537  if (al<2) al = 2;
538  dd = (mp_ptr)omAlloc(sizeof(mp_limb_t)*al);
539  for (i=0;i<size;i++) dd[i] = qp[i];
540  bl = 1-e;
541  nn = (mp_ptr)omAlloc(sizeof(mp_limb_t)*bl);
542  nn[bl-1] = 1;
543  for (i=bl-2;i>=0;i--) nn[i] = 0;
544  ndest = res->n;
545  ndest->_mp_d = nn;
546  ndest->_mp_alloc = ndest->_mp_size = bl;
547  res->s = 0;
548  in=mpz_fdiv_ui(ndest,dst_r->ch);
549  mpz_clear(ndest);
550  }
551  else
552  {
553  al = dest->_mp_size = size+e;
554  if (al<2) al = 2;
555  dd = (mp_ptr)omAlloc(sizeof(mp_limb_t)*al);
556  for (i=0;i<size;i++) dd[i+e] = qp[i];
557  for (i=0;i<e;i++) dd[i] = 0;
558  res->s = 3;
559  }
560 
561  dest->_mp_d = dd;
562  dest->_mp_alloc = al;
563  iz=mpz_fdiv_ui(dest,dst_r->ch);
564  mpz_clear(dest);
565  if(res->s==0)
566  iz=(long)npDiv((number)iz,(number)in,dst_r);
567  FREE_RNUMBER(res); // Q!?
568  return (number)iz;
569 }
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
mpf_t * _mpfp()
Definition: mpr_complex.h:134
#define ALLOC_RNUMBER()
Definition: coeffs.h:87
#define FREE_RNUMBER(x)
Definition: coeffs.h:86
CanonicalForm res
Definition: facAbsFact.cc:60
#define omAlloc(size)
Definition: omAllocDecl.h:210

◆ npMapMachineInt()

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

Definition at line 593 of file modulop.cc.

594 {
595  long i = (long) (((unsigned long) from) % dst->ch);
596  return (number) i;
597 }

◆ npMapP()

static number npMapP ( number  from,
const coeffs  src,
const coeffs  dst_r 
)
static

Definition at line 487 of file modulop.cc.

488 {
489  long i = (long)from;
490  if (i>src->ch/2)
491  {
492  i-=src->ch;
493  while (i < 0) i+=dst_r->ch;
494  }
495  i%=dst_r->ch;
496  return (number)i;
497 }

◆ npMapZ()

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

Definition at line 580 of file modulop.cc.

581 {
582  if (SR_HDL(from) & SR_INT)
583  {
584  long f_i=SR_TO_INT(from);
585  return npInit(f_i,dst);
586  }
587  return npMapGMP(from,src,dst);
588 }
#define SR_INT
Definition: longrat.h:67
#define SR_TO_INT(SR)
Definition: longrat.h:69
static number npMapGMP(number from, const coeffs, const coeffs dst)
Definition: modulop.cc:575
#define SR_HDL(A)
Definition: tgb.cc:35

◆ npNeg()

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

Definition at line 148 of file modulop.cc.

149 {
150  n_Test(c, r);
151 
152  if ((long)c==0L) return c;
153 
154 #if 0
155  number d = npNegM(c,r);
156  n_Test(d, r);
157  return d;
158 #else
159  c = npNegM(c,r);
160  n_Test(c, r);
161  return c;
162 #endif
163 }
static number npNegM(number a, const coeffs r)
Definition: modulop.h:174

◆ npPar()

static number npPar ( int  ,
coeffs  r 
)
static

Definition at line 327 of file modulop.cc.

328 {
329  return (number)(long)r->npExpTable[1];
330 }

◆ npRandom()

static number npRandom ( siRandProc  p,
number  ,
number  ,
const coeffs  cf 
)
static

Definition at line 320 of file modulop.cc.

321 {
322  return npInit(p(),cf);
323 }

◆ npRead()

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

Definition at line 219 of file modulop.cc.

220 {
221  int z;
222  int n=1;
223 
224  s = npEati(s, &z, r);
225  if ((*s) == '/')
226  {
227  s++;
228  s = npEati(s, &n, r);
229  }
230  if (n == 1)
231  *a = (number)(long)z;
232  else
233  {
234  if ((z==0)&&(n==0))
235  {
236  WerrorS(nDivBy0);
237  *a=(number)0L;
238  }
239  else
240  {
241 #ifdef NV_OPS
242  if (r->ch>NV_MAX_PRIME)
243  *a = nvDiv((number)(long)z,(number)(long)n,r);
244  else
245 #endif
246  *a = npDiv((number)(long)z,(number)(long)n,r);
247  }
248  }
249  n_Test(*a, r);
250  return s;
251 }
static const char * npEati(const char *s, int *i, const coeffs r)
Definition: modulop.cc:214

◆ npReadFd()

static number npReadFd ( const ssiInfo d,
const  coeffs 
)
static

Definition at line 312 of file modulop.cc.

313 {
314  // read int
315  int dd;
316  dd=s_readint(d->f_read);
317  return (number)(long)dd;
318 }
int s_readint(s_buff F)
Definition: s_buff.cc:112
s_buff f_read
Definition: s_buff.h:22

◆ npSetMap()

static nMapFunc npSetMap ( const coeffs  src,
const coeffs  dst 
)
static

Definition at line 607 of file modulop.cc.

608 {
609 #ifdef HAVE_RINGS
610  if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src))
611  {
612  return npMapMachineInt;
613  }
614  if (src->rep==n_rep_gmp) //nCoeff_is_Z(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Zn(src))
615  {
616  return npMapGMP;
617  }
618  if (src->rep==n_rep_gap_gmp) //nCoeff_is_Z(src)
619  {
620  return npMapZ;
621  }
622 #endif
623  if (src->rep==n_rep_gap_rat) /* Q, Z */
624  {
625  return nlModP; // npMap0; // FIXME? TODO? // extern number nlModP(number q, const coeffs Q, const coeffs Zp); // Map q \in QQ \to Zp // FIXME!
626  }
627  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src) )
628  {
629  return npMapP;
630  }
631  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
632  {
633  return npMapLongR;
634  }
635  if (nCoeff_is_CF (src))
636  {
637  return npMapCanonicalForm;
638  }
639  return NULL; /* default */
640 }
static FORCE_INLINE BOOLEAN nCoeff_is_long_R(const coeffs r)
Definition: coeffs.h:888
static FORCE_INLINE BOOLEAN nCoeff_is_CF(const coeffs r)
Definition: coeffs.h:894
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:797
static FORCE_INLINE BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
Definition: coeffs.h:721
@ 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
@ n_rep_gmp_float
(gmp_float), see
Definition: coeffs.h:117
@ n_rep_gmp
(mpz_ptr), see rmodulon,h
Definition: coeffs.h:115
number nlModP(number q, const coeffs, const coeffs Zp)
Definition: longrat.cc:1577
static number npMapMachineInt(number from, const coeffs, const coeffs dst)
Definition: modulop.cc:593
static number npMapP(number from, const coeffs src, const coeffs dst_r)
Definition: modulop.cc:487
static number npMapLongR(number from, const coeffs, const coeffs dst_r)
Definition: modulop.cc:499
static number npMapZ(number from, const coeffs src, const coeffs dst)
Definition: modulop.cc:580
static number npMapCanonicalForm(number a, const coeffs, const coeffs dst)
Definition: modulop.cc:600

◆ npWrite()

static void npWrite ( number  a,
const coeffs  r 
)
static

Definition at line 184 of file modulop.cc.

185 {
186  n_Test(a, r);
187 
188  if ((long)a>(((long)r->ch) >>1)) StringAppend("-%d",(int)(((long)r->ch)-((long)a)));
189  else StringAppend("%d",(int)((long)a));
190 }
#define StringAppend
Definition: emacs.cc:79

◆ npWriteFd()

static void npWriteFd ( number  n,
const ssiInfo d,
const  coeffs 
)
static

Definition at line 307 of file modulop.cc.

308 {
309  fprintf(d->f_write,"%d ",(int)(long)n);
310 }
FILE * f_write
Definition: s_buff.h:23

◆ nvDiv()

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

Definition at line 658 of file modulop.cc.

659 {
660  if ((long)a==0L)
661  return (number)0L;
662  else if ((long)b==0L)
663  {
664  WerrorS(nDivBy0);
665  return (number)0L;
666  }
667  else
668  {
669  number inv=nvInversM(b,r);
670  return nvMult(a,inv,r);
671  }
672 }
static number nvInversM(number c, const coeffs r)
Definition: modulop.cc:652

◆ nvInpMult()

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

Definition at line 646 of file modulop.cc.

647 {
648  number n=nvMult(a,b,r);
649  a=n;
650 }

◆ nvInvers()

number nvInvers ( number  c,
const coeffs  r 
)

Definition at line 673 of file modulop.cc.

674 {
675  if ((long)c==0L)
676  {
677  WerrorS(nDivBy0);
678  return (number)0L;
679  }
680  return nvInversM(c,r);
681 }

◆ nvInversM()

static number nvInversM ( number  c,
const coeffs  r 
)
inlinestatic

Definition at line 652 of file modulop.cc.

653 {
654  long inv=npInvMod((long)c,r);
655  return (number)inv;
656 }
static long npInvMod(long a, const coeffs R)
Definition: modulop.h:184