My Project
Loading...
Searching...
No Matches
generics.cc File Reference
#include "misc/auxiliary.h"
#include "factory/factory.h"
#include "misc/mylimits.h"
#include "reporter/reporter.h"
#include "coeffs/coeffs.h"
#include "coeffs/longrat.h"
#include "coeffs/numbers.h"
#include "coeffs/si_gmp.h"
#include "coeffs/generics.h"
#include "coeffs/rintegers.h"
#include <string.h>

Go to the source code of this file.

Data Structures

struct  gcp
 

Functions

static void gCoeffWrite (const coeffs r, BOOLEAN b)
 
static char * gCoeffName (const coeffs r)
 
static void gKillChar (coeffs r)
 
static void gSetChar (coeffs r)
 
static number gMult (number a, number b, const coeffs cf)
 
static number gSub (number a, number b, const coeffs cf)
 
static number gAdd (number a, number b, const coeffs cf)
 
static number gDiv (number a, number b, const coeffs cf)
 
static number gIntMod (number a, number b, const coeffs cf)
 
static number gExactDiv (number a, number b, const coeffs cf)
 
static number gInit (long i, const coeffs cf)
 
static number gInitMPZ (mpz_t i, const coeffs cf)
 
static int gSize (number a, const coeffs)
 
static long gInt (number &a, const coeffs)
 
static void gMPZ (mpz_t result, number &n, const coeffs r)
 
static number gInpNeg (number a, const coeffs r)
 
static number gInvers (number a, const coeffs r)
 
static number gCopy (number a, const coeffs r)
 
static number gRePart (number a, const coeffs r)
 
static number gImPart (number a, const coeffs r)
 
static void gWriteLong (number a, const coeffs r)
 
static void gWriteShort (number a, const coeffs r)
 
static const char * gRead (const char *s, number *a, const coeffs r)
 
static void gNormalize (number &a, const coeffs r)
 
static BOOLEAN gGreater (number a, number b, const coeffs r)
 
static BOOLEAN gEqual (number a, number b, const coeffs r)
 
static BOOLEAN gIsZero (number a, const coeffs r)
 
static BOOLEAN gIsOne (number a, const coeffs r)
 
static BOOLEAN gIsMOne (number a, const coeffs r)
 
static BOOLEAN gGreaterZero (number a, const coeffs r)
 
static void gPower (number a, int i, number *result, const coeffs r)
 
static number gGcd (number a, number b, const coeffs)
 
static number gSubringGcd (number a, number b, const coeffs)
 
static number gGetDenom (number &a, const coeffs)
 
static number gGetNumerator (number &a, const coeffs)
 
static number gQuotRem (number a, number b, number *rem, const coeffs r)
 
static number gLcm (number a, number b, const coeffs r)
 
static number gNormalizeHelper (number a, number b, const coeffs r)
 
static void gDelete (number *a, const coeffs r)
 
static nMapFunc gSetMap (const coeffs src, const coeffs dst)
 
static void gWriteFd (number a, FILE *f, const coeffs r)
 
static number gReadFd (s_buff f, const coeffs r)
 
static number gFarey (number p, number n, const coeffs)
 
static number gChineseRemainder (number *x, number *q, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs)
 
static number gRandom (siRandProc p, number p1, number p2, const coeffs cf)
 
static BOOLEAN gDivBy (number a, number b, const coeffs)
 
static number gExtGcd (number a, number b, number *s, number *t, const coeffs)
 
static number gGetUnit (number n, const coeffs r)
 
static BOOLEAN gIsUnit (number a, const coeffs)
 
static int gDivComp (number a, number b, const coeffs r)
 
static BOOLEAN gDBTest (number a, const char *f, const int l, const coeffs r)
 
BOOLEAN gInitChar (coeffs r, void *p)
 

Variables

VAR coeffs coeffs1
 
VAR coeffs coeffs2
 

Data Structure Documentation

◆ generic_pair

struct generic_pair

Definition at line 27 of file generics.cc.

Data Fields
number a1
number a2

Function Documentation

◆ gAdd()

static number gAdd ( number a,
number b,
const coeffs cf )
static

Definition at line 76 of file generics.cc.

77{
78 gcp aa=(gcp)a;
79 gcp bb=(gcp)b;
80 gcp cc=(gcp)omalloc(sizeof(*cc));
81 cc->a1=coeffs1->cfAdd(aa->a1,bb->a1,coeffs1);
82 cc->a2=coeffs2->cfAdd(aa->a2,bb->a2,coeffs2);
83 n_Test((number)cc,cf);
84 return (number)cc;
85}
CanonicalForm cf
Definition cfModGcd.cc:4091
CanonicalForm b
Definition cfModGcd.cc:4111
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition coeffs.h:713
VAR coeffs coeffs1
Definition generics.cc:33
VAR coeffs coeffs2
Definition generics.cc:33
#define omalloc(size)

◆ gChineseRemainder()

static number gChineseRemainder ( number * x,
number * q,
int rl,
BOOLEAN sym,
CFArray & inv_cache,
const coeffs  )
static

Definition at line 398 of file generics.cc.

399{
400 printf("gChineseREmainder\n");
401 return NULL;
402}
#define NULL
Definition omList.c:12

◆ gCoeffName()

static char * gCoeffName ( const coeffs r)
static

Definition at line 41 of file generics.cc.

42{
43 return coeffs1->cfCoeffName(coeffs1);
44}

◆ gCoeffWrite()

static void gCoeffWrite ( const coeffs r,
BOOLEAN b )
static

Definition at line 35 of file generics.cc.

36{
37 printf("debug: ");
38 coeffs1->cfCoeffWrite(coeffs1,b);
39}

◆ gCopy()

static number gCopy ( number a,
const coeffs r )
static

Definition at line 180 of file generics.cc.

181{
182 gcp aa=(gcp)a;
183 gcp cc=(gcp)omalloc(sizeof(*cc));
184 cc->a1=coeffs1->cfCopy(aa->a1,coeffs1);
185 cc->a2=coeffs2->cfCopy(aa->a2,coeffs2);
186 return (number)cc;
187}

◆ gDBTest()

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

Definition at line 462 of file generics.cc.

463{
464 if (a==NULL)
465 printf("NULL in %s:%d\n",f,l);
466 return TRUE;
467}
#define TRUE
Definition auxiliary.h:101
int l
Definition cfEzgcd.cc:100
FILE * f
Definition checklibs.c:9

◆ gDelete()

static void gDelete ( number * a,
const coeffs r )
static

Definition at line 365 of file generics.cc.

366{
367 if (*a!=NULL)
368 {
369 gcp aa=(gcp)*a;
370 coeffs1->cfDelete(&aa->a1,coeffs1);
371 coeffs2->cfDelete(&aa->a2,coeffs2);
372 omFree(aa);
373 *a=NULL;
374 }
375}
#define omFree(addr)

◆ gDiv()

static number gDiv ( number a,
number b,
const coeffs cf )
static

Definition at line 86 of file generics.cc.

87{
88 gcp aa=(gcp)a;
89 gcp bb=(gcp)b;
90 gcp cc=(gcp)omalloc(sizeof(*cc));
91 cc->a1=coeffs1->cfDiv(aa->a1,bb->a1,coeffs1);
92 cc->a2=coeffs2->cfDiv(aa->a2,bb->a2,coeffs2);
93 n_Test((number)cc,cf);
94 return (number)cc;
95}

◆ gDivBy()

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

Definition at line 408 of file generics.cc.

409{
410 gcp aa=(gcp)a;
411 gcp bb=(gcp)b;
412 BOOLEAN b1=coeffs1->cfDivBy(aa->a1,bb->a1,coeffs1);
413 BOOLEAN b2=coeffs2->cfDivBy(aa->a2,bb->a2,coeffs2);
414 if (b1!=b2)
415 {
416 printf("gDivBy:%d,%d\n",b1,b2);
417 }
418 return b1;
419}
int BOOLEAN
Definition auxiliary.h:88

◆ gDivComp()

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

Definition at line 450 of file generics.cc.

451{
452 gcp aa=(gcp)a;
453 gcp bb=(gcp)b;
454 int i1=coeffs1->cfDivComp(aa->a1,bb->a1,coeffs1);
455 int i2=coeffs2->cfDivComp(aa->a2,bb->a2,coeffs2);
456 if (i1!=i2)
457 {
458 printf("gDivComp:%d,%d\n",i1,i2);
459 }
460 return i1;
461}

◆ gEqual()

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

Definition at line 243 of file generics.cc.

244{
245 gcp aa=(gcp)a;
246 gcp bb=(gcp)b;
247 BOOLEAN b1=coeffs1->cfEqual(aa->a1,bb->a1,coeffs1);
248 BOOLEAN b2=coeffs2->cfEqual(aa->a2,bb->a2,coeffs2);
249 if (b1!=b2)
250 {
251 printf("gEqual\n");
252 }
253 return b1;
254}

◆ gExactDiv()

static number gExactDiv ( number a,
number b,
const coeffs cf )
static

Definition at line 106 of file generics.cc.

107{
108 gcp aa=(gcp)a;
109 gcp bb=(gcp)b;
110 gcp cc=(gcp)omalloc(sizeof(*cc));
111 cc->a1=coeffs1->cfExactDiv(aa->a1,bb->a1,coeffs1);
112 cc->a2=coeffs2->cfExactDiv(aa->a2,bb->a2,coeffs2);
113 n_Test((number)cc,cf);
114 return (number)cc;
115}

◆ gExtGcd()

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

Definition at line 420 of file generics.cc.

421{
422 gcp aa=(gcp)a;
423 gcp bb=(gcp)b;
424 gcp cc=(gcp)omalloc(sizeof(*cc));
425 gcp ss=(gcp)omalloc(sizeof(*ss));
426 gcp tt=(gcp)omalloc(sizeof(*ss));
427 cc->a1=coeffs1->cfExtGcd(aa->a1,bb->a1,&ss->a1,&tt->a1,coeffs1);
428 cc->a2=coeffs2->cfExtGcd(aa->a2,bb->a2,&ss->a2,&tt->a2,coeffs2);
429 return (number)cc;
430}

◆ gFarey()

static number gFarey ( number p,
number n,
const coeffs  )
static

Definition at line 390 of file generics.cc.

391{
392 gcp aa=(gcp)p;
393 gcp cc=(gcp)omalloc(sizeof(*cc));
394 cc->a1=coeffs1->cfFarey(aa->a1,n,coeffs1);
395 cc->a2=coeffs2->cfFarey(aa->a2,n,coeffs2);
396 return (number)cc;
397}
int p
Definition cfModGcd.cc:4086

◆ gGcd()

static number gGcd ( number a,
number b,
const coeffs  )
static

Definition at line 308 of file generics.cc.

309{
310 gcp aa=(gcp)a;
311 gcp bb=(gcp)b;
312 gcp cc=(gcp)omalloc(sizeof(*cc));
313 cc->a1=coeffs1->cfGcd(aa->a1,bb->a1,coeffs1);
314 cc->a2=coeffs2->cfGcd(aa->a2,bb->a2,coeffs2);
315 return (number)cc;
316}

◆ gGetDenom()

static number gGetDenom ( number & a,
const coeffs  )
static

Definition at line 326 of file generics.cc.

327{
328 gcp aa=(gcp)a;
329 gcp cc=(gcp)omalloc(sizeof(*cc));
330 cc->a1=coeffs1->cfGetDenom(aa->a1,coeffs1);
331 cc->a2=coeffs2->cfGetDenom(aa->a2,coeffs2);
332 return (number)cc;
333}

◆ gGetNumerator()

static number gGetNumerator ( number & a,
const coeffs  )
static

Definition at line 334 of file generics.cc.

335{
336 gcp aa=(gcp)a;
337 gcp cc=(gcp)omalloc(sizeof(*cc));
338 cc->a1=coeffs1->cfGetNumerator(aa->a1,coeffs1);
339 cc->a2=coeffs2->cfGetNumerator(aa->a2,coeffs2);
340 return (number)cc;
341}

◆ gGetUnit()

static number gGetUnit ( number n,
const coeffs r )
static

Definition at line 431 of file generics.cc.

432{
433 gcp aa=(gcp)n;
434 gcp cc=(gcp)omalloc(sizeof(*cc));
435 cc->a1=coeffs1->cfGetUnit(aa->a1,coeffs1);
436 cc->a2=coeffs2->cfGetUnit(aa->a2,coeffs2);
437 return (number)cc;
438}

◆ gGreater()

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

Definition at line 231 of file generics.cc.

232{
233 gcp aa=(gcp)a;
234 gcp bb=(gcp)b;
235 BOOLEAN b1=coeffs1->cfGreater(aa->a1,bb->a1,coeffs1);
236 BOOLEAN b2=coeffs2->cfGreater(aa->a2,bb->a2,coeffs2);
237 if (b1!=b2)
238 {
239 printf("gGreater\n");
240 }
241 return b1;
242}

◆ gGreaterZero()

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

Definition at line 289 of file generics.cc.

290{
291 gcp aa=(gcp)a;
292 BOOLEAN b1=coeffs1->cfGreaterZero(aa->a1,coeffs1);
293 BOOLEAN b2=coeffs2->cfGreaterZero(aa->a2,coeffs2);
294 if (b1!=b2)
295 {
296 printf("gGreaterZero\n");
297 }
298 return b1;
299}

◆ gImPart()

static number gImPart ( number a,
const coeffs r )
static

Definition at line 196 of file generics.cc.

197{
198 gcp aa=(gcp)a;
199 gcp cc=(gcp)omalloc(sizeof(*cc));
200 cc->a1=coeffs1->cfRePart(aa->a1,coeffs1);
201 cc->a2=coeffs2->cfRePart(aa->a2,coeffs2);
202 return (number)cc;
203}

◆ gInit()

static number gInit ( long i,
const coeffs cf )
static

Definition at line 116 of file generics.cc.

117{
118 gcp cc=(gcp)omalloc(sizeof(*cc));
119 cc->a1=coeffs1->cfInit(i,coeffs1);
120 cc->a2=coeffs2->cfInit(i,coeffs2);
121 n_Test((number)cc,cf);
122 return (number)cc;
123}
int i
Definition cfEzgcd.cc:132

◆ gInitChar()

BOOLEAN gInitChar ( coeffs r,
void * p )

Definition at line 468 of file generics.cc.

469{
470 coeffs1=nInitChar(n_Z_1,(void*)1);
471 coeffs2=nInitChar(n_Z_2,(void*)1);
472 r->is_field=FALSE;
473 r->is_domain=TRUE;
474 r->rep=n_rep_unknown;
475 r->ch = 0;
476 r->cfKillChar=gKillChar;
477 //r->nCoeffIsEqual=gCoeffsEqual;
478 r->cfCoeffName=gCoeffName;
479 r->cfCoeffWrite=gCoeffWrite;
480
481 r->cfMult = gMult;
482 r->cfSub = gSub;
483 r->cfAdd = gAdd;
484 r->cfDiv = gDiv;
485 r->cfInit = gInit;
486 r->cfSize = gSize;
487 r->cfInt = gInt;
488 r->cfDivComp = gDivComp;
489 r->cfIsUnit = gIsUnit;
490 r->cfGetUnit = gGetUnit;
491 r->cfExtGcd = gExtGcd;
492 r->cfDivBy = gDivBy;
493 r->cfInpNeg = gInpNeg;
494 r->cfInvers= gInvers;
495 r->cfCopy = gCopy;
496 r->cfRePart = gCopy;
497 //r->cfImPart = ndReturn0;
498 r->cfWriteLong = gWriteLong;
499 r->cfWriteShort = gWriteShort;
500 r->cfRead = gRead;
501 r->cfNormalize=gNormalize;
502 r->cfGreater = gGreater;
503 r->cfEqual = gEqual;
504 r->cfIsZero = gIsZero;
505 r->cfIsOne = gIsOne;
506 r->cfIsMOne = gIsMOne;
507 r->cfGreaterZero = gGreaterZero;
508 r->cfPower = gPower;
509 r->cfGetDenom = gGetDenom;
510 r->cfGetNumerator = gGetNumerator;
511 r->cfGcd = gGcd;
512 r->cfLcm = gGcd;
513 r->cfDelete= gDelete;
514 r->cfSetMap = gSetMap;
515 //r->cfInpMult=ndInpMult;
516 r->cfRandom=gRandom;
517 r->cfWriteFd=gWriteFd;
518 r->cfReadFd=gReadFd;
519 r->type=n_Z;
520 #ifdef LDEBUG
521 r->cfDBTest=gDBTest;
522 #endif
523 return FALSE;
524}
#define FALSE
Definition auxiliary.h:97
@ n_Z
only used if HAVE_RINGS is defined
Definition coeffs.h:43
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:406
@ n_rep_unknown
Definition coeffs.h:116
static int gDivComp(number a, number b, const coeffs r)
Definition generics.cc:450
static void gWriteFd(number a, FILE *f, const coeffs r)
Definition generics.cc:381
static number gCopy(number a, const coeffs r)
Definition generics.cc:180
static number gGcd(number a, number b, const coeffs)
Definition generics.cc:308
static number gMult(number a, number b, const coeffs cf)
Definition generics.cc:56
static BOOLEAN gIsMOne(number a, const coeffs r)
Definition generics.cc:278
static void gWriteShort(number a, const coeffs r)
Definition generics.cc:209
static BOOLEAN gDivBy(number a, number b, const coeffs)
Definition generics.cc:408
static void gNormalize(number &a, const coeffs r)
Definition generics.cc:225
static long gInt(number &a, const coeffs)
Definition generics.cc:143
static number gAdd(number a, number b, const coeffs cf)
Definition generics.cc:76
static BOOLEAN gIsUnit(number a, const coeffs)
Definition generics.cc:439
static void gPower(number a, int i, number *result, const coeffs r)
Definition generics.cc:300
static number gInpNeg(number a, const coeffs r)
Definition generics.cc:165
static BOOLEAN gGreaterZero(number a, const coeffs r)
Definition generics.cc:289
static void gKillChar(coeffs r)
Definition generics.cc:45
static number gGetUnit(number n, const coeffs r)
Definition generics.cc:431
static number gInit(long i, const coeffs cf)
Definition generics.cc:116
static void gCoeffWrite(const coeffs r, BOOLEAN b)
Definition generics.cc:35
static number gGetDenom(number &a, const coeffs)
Definition generics.cc:326
static BOOLEAN gEqual(number a, number b, const coeffs r)
Definition generics.cc:243
static number gGetNumerator(number &a, const coeffs)
Definition generics.cc:334
static number gRandom(siRandProc p, number p1, number p2, const coeffs cf)
Definition generics.cc:403
static BOOLEAN gGreater(number a, number b, const coeffs r)
Definition generics.cc:231
static number gExtGcd(number a, number b, number *s, number *t, const coeffs)
Definition generics.cc:420
static void gWriteLong(number a, const coeffs r)
Definition generics.cc:204
static BOOLEAN gDBTest(number a, const char *f, const int l, const coeffs r)
Definition generics.cc:462
static const char * gRead(const char *s, number *a, const coeffs r)
Definition generics.cc:214
static number gReadFd(s_buff f, const coeffs r)
Definition generics.cc:385
static nMapFunc gSetMap(const coeffs src, const coeffs dst)
Definition generics.cc:376
static BOOLEAN gIsZero(number a, const coeffs r)
Definition generics.cc:255
static char * gCoeffName(const coeffs r)
Definition generics.cc:41
static number gInvers(number a, const coeffs r)
Definition generics.cc:172
static void gDelete(number *a, const coeffs r)
Definition generics.cc:365
static int gSize(number a, const coeffs)
Definition generics.cc:132
static number gSub(number a, number b, const coeffs cf)
Definition generics.cc:66
static number gDiv(number a, number b, const coeffs cf)
Definition generics.cc:86
static BOOLEAN gIsOne(number a, const coeffs r)
Definition generics.cc:267

◆ gInitMPZ()

static number gInitMPZ ( mpz_t i,
const coeffs cf )
static

Definition at line 124 of file generics.cc.

125{
126 gcp cc=(gcp)omalloc(sizeof(*cc));
127 cc->a1=coeffs1->cfInitMPZ(i,coeffs1);
128 cc->a2=coeffs2->cfInitMPZ(i,coeffs2);
129 n_Test((number)cc,cf);
130 return (number)cc;
131}

◆ gInpNeg()

static number gInpNeg ( number a,
const coeffs r )
static

Definition at line 165 of file generics.cc.

166{
167 gcp aa=(gcp)a;
168 aa->a1=coeffs1->cfInpNeg(aa->a1,coeffs1);
169 aa->a2=coeffs2->cfInpNeg(aa->a2,coeffs2);
170 return (number)aa;
171}

◆ gInt()

static long gInt ( number & a,
const coeffs  )
static

Definition at line 143 of file generics.cc.

144{
145 gcp aa=(gcp)a;
146 long s1=coeffs1->cfInt(aa->a1,coeffs1);
147 long s2=coeffs2->cfInt(aa->a2,coeffs2);
148 if (s1!=s2)
149 {
150 printf("gInt: %ld, %ld\n",s1,s2);
151 }
152 return s1;
153}

◆ gIntMod()

static number gIntMod ( number a,
number b,
const coeffs cf )
static

Definition at line 96 of file generics.cc.

97{
98 gcp aa=(gcp)a;
99 gcp bb=(gcp)b;
100 gcp cc=(gcp)omalloc(sizeof(*cc));
101 cc->a1=coeffs1->cfIntMod(aa->a1,bb->a1,coeffs1);
102 cc->a2=coeffs2->cfIntMod(aa->a2,bb->a2,coeffs2);
103 n_Test((number)cc,cf);
104 return (number)cc;
105}

◆ gInvers()

static number gInvers ( number a,
const coeffs r )
static

Definition at line 172 of file generics.cc.

173{
174 gcp aa=(gcp)a;
175 gcp cc=(gcp)omalloc(sizeof(*cc));
176 cc->a1=coeffs1->cfInvers(aa->a1,coeffs1);
177 cc->a2=coeffs2->cfInvers(aa->a2,coeffs2);
178 return (number)cc;
179}

◆ gIsMOne()

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

Definition at line 278 of file generics.cc.

279{
280 gcp aa=(gcp)a;
281 BOOLEAN b1=coeffs1->cfIsMOne(aa->a1,coeffs1);
282 BOOLEAN b2=coeffs2->cfIsMOne(aa->a2,coeffs2);
283 if (b1!=b2)
284 {
285 printf("gIsMOne\n");
286 }
287 return b1;
288}

◆ gIsOne()

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

Definition at line 267 of file generics.cc.

268{
269 gcp aa=(gcp)a;
270 BOOLEAN b1=coeffs1->cfIsOne(aa->a1,coeffs1);
271 BOOLEAN b2=coeffs2->cfIsOne(aa->a2,coeffs2);
272 if (b1!=b2)
273 {
274 printf("gIsOne\n");
275 }
276 return b1;
277}

◆ gIsUnit()

static BOOLEAN gIsUnit ( number a,
const coeffs  )
static

Definition at line 439 of file generics.cc.

440{
441 gcp aa=(gcp)a;
442 BOOLEAN b1=coeffs1->cfIsUnit(aa->a1,coeffs1);
443 BOOLEAN b2=coeffs2->cfIsUnit(aa->a2,coeffs2);
444 if (b1!=b2)
445 {
446 printf("gIsUnit:%d,%d\n",b1,b2);
447 }
448 return b1;
449}

◆ gIsZero()

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

Definition at line 255 of file generics.cc.

256{
257 if (a==NULL) return TRUE;
258 gcp aa=(gcp)a;
259 BOOLEAN b1=coeffs1->cfIsZero(aa->a1,coeffs1);
260 BOOLEAN b2=coeffs2->cfIsZero(aa->a2,coeffs2);
261 if (b1!=b2)
262 {
263 printf("gIsZero\n");
264 }
265 return b1;
266}

◆ gKillChar()

static void gKillChar ( coeffs r)
static

Definition at line 45 of file generics.cc.

46{
47 coeffs1->cfKillChar(coeffs1);
48 coeffs2->cfKillChar(coeffs2);
49}

◆ gLcm()

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

Definition at line 347 of file generics.cc.

348{
349 gcp aa=(gcp)a;
350 gcp bb=(gcp)b;
351 gcp cc=(gcp)omalloc(sizeof(*cc));
352 cc->a1=coeffs1->cfLcm(aa->a1,bb->a1,coeffs1);
353 cc->a2=coeffs2->cfLcm(aa->a2,bb->a2,coeffs2);
354 return (number)cc;
355}

◆ gMPZ()

static void gMPZ ( mpz_t result,
number & n,
const coeffs r )
static

Definition at line 154 of file generics.cc.

155{
156 coeffs1->cfMPZ(result,n,coeffs1);
157 mpz_t r2;
158 coeffs2->cfMPZ(r2,n,coeffs2);
159 if(mpz_cmp(result,r2)!=0)
160 {
161 printf("gMPZ\n");
162 }
163 mpz_clear(r2);
164}
return result

◆ gMult()

static number gMult ( number a,
number b,
const coeffs cf )
static

Definition at line 56 of file generics.cc.

57{
58 gcp aa=(gcp)a;
59 gcp bb=(gcp)b;
60 gcp cc=(gcp)omalloc(sizeof(*cc));
61 cc->a1=coeffs1->cfMult(aa->a1,bb->a1,coeffs1);
62 cc->a2=coeffs2->cfMult(aa->a2,bb->a2,coeffs2);
63 n_Test((number)cc,cf);
64 return (number)cc;
65}

◆ gNormalize()

static void gNormalize ( number & a,
const coeffs r )
static

Definition at line 225 of file generics.cc.

226{
227 gcp aa=(gcp)a;
228 coeffs1->cfNormalize(aa->a1,coeffs1);
229 coeffs2->cfNormalize(aa->a2,coeffs2);
230}

◆ gNormalizeHelper()

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

Definition at line 356 of file generics.cc.

357{
358 gcp aa=(gcp)a;
359 gcp bb=(gcp)b;
360 gcp cc=(gcp)omalloc(sizeof(*cc));
361 cc->a1=coeffs1->cfNormalizeHelper(aa->a1,bb->a1,coeffs1);
362 cc->a2=coeffs2->cfNormalizeHelper(aa->a2,bb->a2,coeffs2);
363 return (number)cc;
364}

◆ gPower()

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

Definition at line 300 of file generics.cc.

301{
302 gcp aa=(gcp)a;
303 gcp cc=(gcp)omalloc(sizeof(*cc));
304 coeffs1->cfPower(aa->a1,i,&cc->a1,coeffs1);
305 coeffs2->cfPower(aa->a2,i,&cc->a2,coeffs2);
306 *result=(number)cc;
307}

◆ gQuotRem()

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

Definition at line 342 of file generics.cc.

343{
344 printf("gQuotRem\n");
345 return NULL;
346}

◆ gRandom()

static number gRandom ( siRandProc p,
number p1,
number p2,
const coeffs cf )
static

Definition at line 403 of file generics.cc.

404{
405 printf("gRandom\n");
406 return NULL;
407}

◆ gRead()

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

Definition at line 214 of file generics.cc.

215{
216 gcp cc=(gcp)omalloc(sizeof(*cc));
217 const char* ss=coeffs1->cfRead(s,&(cc->a1),coeffs1);
218 number tmp=coeffs2->cfInit(1,coeffs2);
219 mpz_ptr tt=(mpz_ptr)tmp;
220 coeffs1->cfMPZ(tt,cc->a1,coeffs1);
221 cc->a2=(number)tt;
222 *a=(number)cc;
223 return ss;
224}
const CanonicalForm int s
Definition facAbsFact.cc:51

◆ gReadFd()

static number gReadFd ( s_buff f,
const coeffs r )
static

Definition at line 385 of file generics.cc.

386{
387 printf("gReadFd\n");
388 return NULL;
389}

◆ gRePart()

static number gRePart ( number a,
const coeffs r )
static

Definition at line 188 of file generics.cc.

189{
190 gcp aa=(gcp)a;
191 gcp cc=(gcp)omalloc(sizeof(*cc));
192 cc->a1=coeffs1->cfRePart(aa->a1,coeffs1);
193 cc->a2=coeffs2->cfRePart(aa->a2,coeffs2);
194 return (number)cc;
195}

◆ gSetChar()

static void gSetChar ( coeffs r)
static

Definition at line 50 of file generics.cc.

51{
52 coeffs1->cfSetChar(coeffs1);
53 coeffs2->cfSetChar(coeffs2);
54}

◆ gSetMap()

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

Definition at line 376 of file generics.cc.

377{
378 printf("gSetMap\n");
379 return NULL;
380}

◆ gSize()

static int gSize ( number a,
const coeffs  )
static

Definition at line 132 of file generics.cc.

133{
134 gcp aa=(gcp)a;
135 int s1=coeffs1->cfSize(aa->a1,coeffs1);
136 int s2=coeffs2->cfSize(aa->a2,coeffs2);
137 if (s1!=s2)
138 {
139 printf("gSize: %d, %d\n",s1,s2);
140 }
141 return s1;
142}

◆ gSub()

static number gSub ( number a,
number b,
const coeffs cf )
static

Definition at line 66 of file generics.cc.

67{
68 gcp aa=(gcp)a;
69 gcp bb=(gcp)b;
70 gcp cc=(gcp)omalloc(sizeof(*cc));
71 cc->a1=coeffs1->cfSub(aa->a1,bb->a1,coeffs1);
72 cc->a2=coeffs2->cfSub(aa->a2,bb->a2,coeffs2);
73 n_Test((number)cc,cf);
74 return (number)cc;
75}

◆ gSubringGcd()

static number gSubringGcd ( number a,
number b,
const coeffs  )
static

Definition at line 317 of file generics.cc.

318{
319 gcp aa=(gcp)a;
320 gcp bb=(gcp)b;
321 gcp cc=(gcp)omalloc(sizeof(*cc));
322 cc->a1=coeffs1->cfSubringGcd(aa->a1,bb->a1,coeffs1);
323 cc->a2=coeffs2->cfSubringGcd(aa->a2,bb->a2,coeffs2);
324 return (number)cc;
325}

◆ gWriteFd()

static void gWriteFd ( number a,
FILE * f,
const coeffs r )
static

Definition at line 381 of file generics.cc.

382{
383 printf("gWriteFd\n");
384}

◆ gWriteLong()

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

Definition at line 204 of file generics.cc.

205{
206 gcp aa=(gcp)a;
207 coeffs1->cfWriteLong(aa->a1,coeffs1);
208}

◆ gWriteShort()

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

Definition at line 209 of file generics.cc.

210{
211 gcp aa=(gcp)a;
212 coeffs1->cfWriteShort(aa->a1,coeffs1);
213}

Variable Documentation

◆ coeffs1

VAR coeffs coeffs1

Definition at line 33 of file generics.cc.

◆ coeffs2

VAR coeffs coeffs2

Definition at line 33 of file generics.cc.