My Project
Loading...
Searching...
No Matches
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 {
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 char * npCoeffName(const coeffs cf)
Definition: modulop.cc:300
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
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 {
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 {
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 {
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