My Project  debian-1:4.1.1-p2+ds-4build2
Data Structures | Functions
algext.h File Reference
#include "coeffs/coeffs.h"
#include "polys/monomials/ring.h"

Go to the source code of this file.

Data Structures

struct  AlgExtInfo
 struct for passing initialization parameters to naInitChar More...
 

Functions

nMapFunc naSetMap (const coeffs src, const coeffs dst)
 Get a mapping function from src into the domain of this type (n_algExt) More...
 
BOOLEAN naInitChar (coeffs cf, void *infoStruct)
 Initialize the coeffs object. More...
 
BOOLEAN n2pInitChar (coeffs cf, void *infoStruct)
 
int naIsParam (number, const coeffs)
 if m == var(i)/1 => return i, More...
 
poly p_ExtGcd (poly p, poly &pFactor, poly q, poly &qFactor, ring r)
 assumes that p and q are univariate polynomials in r, mentioning the same variable; assumes a global monomial ordering in r; assumes that not both p and q are NULL; returns the gcd of p and q; moreover, afterwards pFactor and qFactor contain appropriate factors such that gcd(p, q) = p * pFactor + q * qFactor; leaves p and q unmodified More...
 
char * naCoeffString (const coeffs r)
 
char * naCoeffName (const coeffs r)
 

Data Structure Documentation

◆ AlgExtInfo

struct AlgExtInfo

struct for passing initialization parameters to naInitChar

Definition at line 37 of file algext.h.

Data Fields
ring r

Function Documentation

◆ n2pInitChar()

BOOLEAN n2pInitChar ( coeffs  cf,
void *  infoStruct 
)

first check whether cf->extRing != NULL and delete old ring???

Definition at line 1679 of file algext.cc.

1680 {
1681  assume( infoStruct != NULL );
1682 
1683  AlgExtInfo *e = (AlgExtInfo *)infoStruct;
1684  /// first check whether cf->extRing != NULL and delete old ring???
1685 
1686  assume(e->r != NULL); // extRing;
1687  assume(e->r->cf != NULL); // extRing->cf;
1688 
1689  assume( cf != NULL );
1690 
1691  e->r->ref ++; // increase the ref.counter for the ground poly. ring!
1692  const ring R = e->r; // no copy!
1693  cf->extRing = R;
1694 
1695  /* propagate characteristic up so that it becomes
1696  directly accessible in cf: */
1697  cf->ch = R->cf->ch;
1698  cf->is_field=FALSE;
1699  cf->is_domain=TRUE;
1700 
1701  cf->cfCoeffString = n2pCoeffString;
1702  cf->cfCoeffName = n2pCoeffName;
1703 
1704  cf->cfGreaterZero = naGreaterZero;
1705  cf->cfGreater = naGreater;
1706  cf->cfEqual = naEqual;
1707  cf->cfIsZero = naIsZero;
1708  cf->cfIsOne = naIsOne;
1709  cf->cfIsMOne = naIsMOne;
1710  cf->cfInit = naInit;
1711  cf->cfFarey = naFarey;
1712  cf->cfChineseRemainder= naChineseRemainder;
1713  cf->cfInt = naInt;
1714  cf->cfInpNeg = naNeg;
1715  cf->cfAdd = naAdd;
1716  cf->cfSub = naSub;
1717  cf->cfMult = n2pMult;
1718  cf->cfDiv = n2pDiv;
1719  cf->cfPower = n2pPower;
1720  cf->cfCopy = naCopy;
1721 
1722  cf->cfWriteLong = naWriteLong;
1723 
1724  if( rCanShortOut(n2pRing) )
1725  cf->cfWriteShort = naWriteShort;
1726  else
1727  cf->cfWriteShort = naWriteLong;
1728 
1729  cf->cfRead = n2pRead;
1730  cf->cfDelete = naDelete;
1731  cf->cfSetMap = naSetMap;
1732  cf->cfGetDenom = naGetDenom;
1733  cf->cfGetNumerator = naGetNumerator;
1734  cf->cfRePart = naCopy;
1735  cf->cfCoeffWrite = n2pCoeffWrite;
1736  cf->cfNormalize = n2pNormalize;
1737  cf->cfKillChar = naKillChar;
1738 #ifdef LDEBUG
1739  cf->cfDBTest = naDBTest;
1740 #endif
1741  cf->cfGcd = naGcd;
1742  cf->cfNormalizeHelper = naLcmContent;
1743  cf->cfSize = naSize;
1744  cf->nCoeffIsEqual = n2pCoeffIsEqual;
1745  cf->cfInvers = n2pInvers;
1746  cf->convFactoryNSingN=naConvFactoryNSingN;
1747  cf->convSingNFactoryN=naConvSingNFactoryN;
1748  cf->cfParDeg = naParDeg;
1749 
1750  cf->iNumberOfParameters = rVar(R);
1751  cf->pParameterNames = (const char**)R->names;
1752  cf->cfParameter = naParameter;
1753  cf->has_simple_Inverse=FALSE;
1754  /* cf->has_simple_Alloc= FALSE; */
1755 
1756  if( nCoeff_is_Q(R->cf) )
1757  {
1758  cf->cfClearContent = naClearContent;
1759  cf->cfClearDenominators = naClearDenominators;
1760  }
1761 
1762  return FALSE;
1763 }

◆ naCoeffName()

char* naCoeffName ( const coeffs  r)

Definition at line 1352 of file algext.cc.

1353 {
1354  const char* const* p=n_ParameterNames(r);
1355  int l=0;
1356  int i;
1357  for(i=0; i<n_NumberOfParameters(r);i++)
1358  {
1359  l+=(strlen(p[i])+1);
1360  }
1361  static char s[200];
1362  s[0]='\0';
1363  snprintf(s,10+1,"%d",r->ch); /* Fp(a) or Q(a) */
1364  char tt[2];
1365  tt[0]=',';
1366  tt[1]='\0';
1367  for(i=0; i<n_NumberOfParameters(r);i++)
1368  {
1369  strcat(s,tt);
1370  strcat(s,p[i]);
1371  }
1372  return s;
1373 }

◆ naCoeffString()

char* naCoeffString ( const coeffs  r)

Definition at line 1329 of file algext.cc.

1330 {
1331  const char* const* p=n_ParameterNames(r);
1332  int l=0;
1333  int i;
1334  for(i=0; i<n_NumberOfParameters(r);i++)
1335  {
1336  l+=(strlen(p[i])+1);
1337  }
1338  char *s=(char *)omAlloc(l+10+1);
1339  s[0]='\0';
1340  snprintf(s,10+1,"%d",r->ch); /* Fp(a) or Q(a) */
1341  char tt[2];
1342  tt[0]=',';
1343  tt[1]='\0';
1344  for(i=0; i<n_NumberOfParameters(r);i++)
1345  {
1346  strcat(s,tt);
1347  strcat(s,p[i]);
1348  }
1349  return s;
1350 }

◆ naInitChar()

BOOLEAN naInitChar ( coeffs  cf,
void *  infoStruct 
)

Initialize the coeffs object.

first check whether cf->extRing != NULL and delete old ring???

Definition at line 1395 of file algext.cc.

1396 {
1397  assume( infoStruct != NULL );
1398 
1399  AlgExtInfo *e = (AlgExtInfo *)infoStruct;
1400  /// first check whether cf->extRing != NULL and delete old ring???
1401 
1402  assume(e->r != NULL); // extRing;
1403  assume(e->r->cf != NULL); // extRing->cf;
1404 
1405  assume((e->r->qideal != NULL) && // minideal has one
1406  (IDELEMS(e->r->qideal) == 1) && // non-zero generator
1407  (e->r->qideal->m[0] != NULL) ); // at m[0];
1408 
1409  assume( cf != NULL );
1410  assume(getCoeffType(cf) == n_algExt); // coeff type;
1411 
1412  e->r->ref ++; // increase the ref.counter for the ground poly. ring!
1413  const ring R = e->r; // no copy!
1414  cf->extRing = R;
1415 
1416  /* propagate characteristic up so that it becomes
1417  directly accessible in cf: */
1418  cf->ch = R->cf->ch;
1419 
1420  cf->is_field=TRUE;
1421  cf->is_domain=TRUE;
1422  cf->rep=n_rep_poly;
1423 
1424  #ifdef LDEBUG
1425  p_Test((poly)naMinpoly, naRing);
1426  #endif
1427 
1428  cf->cfCoeffString = naCoeffString;
1429  cf->cfCoeffName = naCoeffName;
1430 
1431  cf->cfGreaterZero = naGreaterZero;
1432  cf->cfGreater = naGreater;
1433  cf->cfEqual = naEqual;
1434  cf->cfIsZero = naIsZero;
1435  cf->cfIsOne = naIsOne;
1436  cf->cfIsMOne = naIsMOne;
1437  cf->cfInit = naInit;
1438  cf->cfFarey = naFarey;
1439  cf->cfChineseRemainder= naChineseRemainder;
1440  cf->cfInt = naInt;
1441  cf->cfInpNeg = naNeg;
1442  cf->cfAdd = naAdd;
1443  cf->cfSub = naSub;
1444  cf->cfMult = naMult;
1445  cf->cfDiv = naDiv;
1446  cf->cfExactDiv = naDiv;
1447  cf->cfPower = naPower;
1448  cf->cfCopy = naCopy;
1449 
1450  cf->cfWriteLong = naWriteLong;
1451 
1452  if( rCanShortOut(naRing) )
1453  cf->cfWriteShort = naWriteShort;
1454  else
1455  cf->cfWriteShort = naWriteLong;
1456 
1457  cf->cfRead = naRead;
1458  cf->cfDelete = naDelete;
1459  cf->cfSetMap = naSetMap;
1460  cf->cfGetDenom = naGetDenom;
1461  cf->cfGetNumerator = naGetNumerator;
1462  cf->cfRePart = naCopy;
1463  cf->cfCoeffWrite = naCoeffWrite;
1464  cf->cfNormalize = naNormalize;
1465  cf->cfKillChar = naKillChar;
1466 #ifdef LDEBUG
1467  cf->cfDBTest = naDBTest;
1468 #endif
1469  cf->cfGcd = naGcd;
1470  cf->cfNormalizeHelper = naLcmContent;
1471  cf->cfSize = naSize;
1472  cf->nCoeffIsEqual = naCoeffIsEqual;
1473  cf->cfInvers = naInvers;
1474  cf->convFactoryNSingN=naConvFactoryNSingN;
1475  cf->convSingNFactoryN=naConvSingNFactoryN;
1476  cf->cfParDeg = naParDeg;
1477 
1478  cf->iNumberOfParameters = rVar(R);
1479  cf->pParameterNames = (const char**)R->names;
1480  cf->cfParameter = naParameter;
1481  cf->has_simple_Inverse= R->cf->has_simple_Inverse;
1482  /* cf->has_simple_Alloc= FALSE; */
1483 
1484  if( nCoeff_is_Q(R->cf) )
1485  {
1486  cf->cfClearContent = naClearContent;
1487  cf->cfClearDenominators = naClearDenominators;
1488  }
1489 
1490  return FALSE;
1491 }

◆ naIsParam()

int naIsParam ( number  ,
const  coeffs 
)

if m == var(i)/1 => return i,

Definition at line 1095 of file algext.cc.

1096 {
1098 
1099  const ring R = cf->extRing;
1100  assume( R != NULL );
1101 
1102  return p_Var( (poly)m, R );
1103 }

◆ naSetMap()

nMapFunc naSetMap ( const coeffs  src,
const coeffs  dst 
)

Get a mapping function from src into the domain of this type (n_algExt)

Q or Z --> Q(a)

Z --> Q(a)

Z/p --> Q(a)

Q --> Z/p(a)

Z --> Z/p(a)

Z/p --> Z/p(a)

Z/u --> Z/p(a)

default

Definition at line 1019 of file algext.cc.

1020 {
1021  /* dst is expected to be an algebraic field extension */
1022  assume(getCoeffType(dst) == n_algExt);
1023 
1024  if( src == dst ) return ndCopyMap;
1025 
1026  int h = 0; /* the height of the extension tower given by dst */
1027  coeffs bDst = nCoeff_bottom(dst, h); /* the bottom field in the tower dst */
1028  coeffs bSrc = nCoeff_bottom(src, h); /* the bottom field in the tower src */
1029 
1030  /* for the time being, we only provide maps if h = 1 or 0 */
1031  if (h==0)
1032  {
1033  if ((src->rep==n_rep_gap_rat) && nCoeff_is_Q(bDst))
1034  return naMap00; /// Q or Z --> Q(a)
1035  if ((src->rep==n_rep_gap_gmp) && nCoeff_is_Q(bDst))
1036  return naMapZ0; /// Z --> Q(a)
1037  if (nCoeff_is_Zp(src) && nCoeff_is_Q(bDst))
1038  return naMapP0; /// Z/p --> Q(a)
1039  if (nCoeff_is_Q_or_BI(src) && nCoeff_is_Zp(bDst))
1040  return naMap0P; /// Q --> Z/p(a)
1041  if ((src->rep==n_rep_gap_gmp) && nCoeff_is_Zp(bDst))
1042  return naMapZ0; /// Z --> Z/p(a)
1043  if (nCoeff_is_Zp(src) && nCoeff_is_Zp(bDst))
1044  {
1045  if (src->ch == dst->ch) return naMapPP; /// Z/p --> Z/p(a)
1046  else return naMapUP; /// Z/u --> Z/p(a)
1047  }
1048  }
1049  if (h != 1) return NULL;
1050  if ((!nCoeff_is_Zp(bDst)) && (!nCoeff_is_Q(bDst))) return NULL;
1051  if ((!nCoeff_is_Zp(bSrc)) && (!nCoeff_is_Q_or_BI(bSrc))) return NULL;
1052 
1053  nMapFunc nMap=n_SetMap(src->extRing->cf,dst->extRing->cf);
1054  if (rSamePolyRep(src->extRing, dst->extRing) && (strcmp(rRingVar(0, src->extRing), rRingVar(0, dst->extRing)) == 0))
1055  {
1056  if (src->type==n_algExt)
1057  return ndCopyMap; // naCopyMap; /// K(a) --> K(a)
1058  else
1059  return naCopyTrans2AlgExt;
1060  }
1061  else if ((nMap!=NULL) && (strcmp(rRingVar(0,src->extRing),rRingVar(0,dst->extRing))==0) && (rVar (src->extRing) == rVar (dst->extRing)))
1062  {
1063  if (src->type==n_algExt)
1064  return naGenMap; // naCopyMap; /// K(a) --> K'(a)
1065  else
1066  return naGenTrans2AlgExt;
1067  }
1068 
1069  return NULL; /// default
1070 }

◆ p_ExtGcd()

poly p_ExtGcd ( poly  p,
poly &  pFactor,
poly  q,
poly &  qFactor,
ring  r 
)

assumes that p and q are univariate polynomials in r, mentioning the same variable; assumes a global monomial ordering in r; assumes that not both p and q are NULL; returns the gcd of p and q; moreover, afterwards pFactor and qFactor contain appropriate factors such that gcd(p, q) = p * pFactor + q * qFactor; leaves p and q unmodified

Definition at line 218 of file algext.cc.

219 {
220  assume((p != NULL) || (q != NULL));
221  poly a = p; poly b = q; BOOLEAN aCorrespondsToP = TRUE;
222  if (p_Deg(a, r) < p_Deg(b, r))
223  { a = q; b = p; aCorrespondsToP = FALSE; }
224  a = p_Copy(a, r); b = p_Copy(b, r);
225  poly aFactor = NULL; poly bFactor = NULL;
226  poly theGcd = p_ExtGcdHelper(a, aFactor, b, bFactor, r);
227  if (aCorrespondsToP) { pFactor = aFactor; qFactor = bFactor; }
228  else { pFactor = bFactor; qFactor = aFactor; }
229  return theGcd;
230 }
getCoeffType
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
n_rep_gap_rat
@ n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:112
FALSE
#define FALSE
Definition: auxiliary.h:94
n2pCoeffString
char * n2pCoeffString(const coeffs cf)
Definition: algext.cc:1595
nCoeff_is_Zp
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:831
naSetMap
nMapFunc naSetMap(const coeffs src, const coeffs dst)
Get a mapping function from src into the domain of this type (n_algExt)
Definition: algext.cc:1019
naCoeffWrite
void naCoeffWrite(const coeffs cf, BOOLEAN details)
Definition: algext.cc:389
rCanShortOut
static BOOLEAN rCanShortOut(const ring r)
Definition: ring.h:577
naIsOne
BOOLEAN naIsOne(number a, const coeffs cf)
Definition: algext.cc:317
naCoeffName
char * naCoeffName(const coeffs r)
Definition: algext.cc:1352
n2pCoeffWrite
void n2pCoeffWrite(const coeffs cf, BOOLEAN details)
Definition: algext.cc:1651
n2pRead
const char * n2pRead(const char *s, number *a, const coeffs cf)
Definition: algext.cc:1566
n2pPower
void n2pPower(number a, int exp, number *b, const coeffs cf)
Definition: algext.cc:1559
naDiv
number naDiv(number a, number b, const coeffs cf)
Definition: algext.cc:471
naGenMap
number naGenMap(number a, const coeffs cf, const coeffs dst)
Definition: algext.cc:974
naGcd
number naGcd(number a, number b, const coeffs cf)
Definition: algext.cc:772
p_Var
int p_Var(poly m, const ring r)
Definition: p_polys.cc:4540
n2pInvers
number n2pInvers(number a, const coeffs cf)
Definition: algext.cc:1663
naChineseRemainder
number naChineseRemainder(number *x, number *q, int rl, BOOLEAN, CFArray &inv_cache, const coeffs cf)
Definition: algext.cc:1375
cf
CanonicalForm cf
Definition: cfModGcd.cc:4024
naParDeg
int naParDeg(number a, const coeffs cf)
Definition: algext.cc:1072
naInvers
number naInvers(number a, const coeffs cf)
Definition: algext.cc:820
naFarey
number naFarey(number p, number n, const coeffs cf)
Definition: algext.cc:1387
naMap00
number naMap00(number a, const coeffs src, const coeffs dst)
Definition: algext.cc:850
naWriteLong
void naWriteLong(number a, const coeffs cf)
Definition: algext.cc:572
nCoeff_is_Q_or_BI
static FORCE_INLINE BOOLEAN nCoeff_is_Q_or_BI(const coeffs r)
Definition: coeffs.h:843
nCoeff_bottom
static coeffs nCoeff_bottom(const coeffs r, int &height)
Definition: algext.cc:260
ndCopyMap
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:251
naMinpoly
#define naMinpoly
Definition: algext.cc:72
naDBTest
BOOLEAN naDBTest(number a, const char *f, const int l, const coeffs r)
Definition: algext.cc:235
p_Test
#define p_Test(p, r)
Definition: p_polys.h:163
naMapPP
number naMapPP(number a, const coeffs src, const coeffs dst)
Definition: algext.cc:953
naAdd
number naAdd(number a, number b, const coeffs cf)
Definition: algext.cc:439
n_NumberOfParameters
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:805
naConvSingNFactoryN
CanonicalForm naConvSingNFactoryN(number n, BOOLEAN, const coeffs cf)
Definition: algext.cc:758
b
CanonicalForm b
Definition: cfModGcd.cc:4044
n2pMult
number n2pMult(number a, number b, const coeffs cf)
Definition: algext.cc:1542
naLcmContent
number naLcmContent(number a, number b, const coeffs cf)
Definition: algext.cc:645
nCoeff_is_Q
static FORCE_INLINE BOOLEAN nCoeff_is_Q(const coeffs r)
Definition: coeffs.h:837
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:812
naCopy
number naCopy(number a, const coeffs cf)
Definition: algext.cc:298
rVar
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:583
n_polyExt
@ n_polyExt
used to represent polys as coeffcients
Definition: coeffs.h:35
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
AlgExtInfo
struct for passing initialization parameters to naInitChar
Definition: algext.h:37
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:74
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
rRingVar
static char * rRingVar(short i, const ring r)
Definition: ring.h:568
naClearContent
void naClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition: algext.cc:1106
naRing
#define naRing
Definition: algext.cc:63
naClearDenominators
void naClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition: algext.cc:1307
naGreaterZero
BOOLEAN naGreaterZero(number a, const coeffs cf)
forward declarations
Definition: algext.cc:380
naGreater
BOOLEAN naGreater(number a, number b, const coeffs cf)
Definition: algext.cc:360
naSize
int naSize(number a, const coeffs cf)
Definition: algext.cc:714
n2pCoeffName
char * n2pCoeffName(const coeffs cf)
Definition: algext.cc:1623
h
static Poly * h
Definition: janet.cc:972
naParameter
number naParameter(const int iParameter, const coeffs cf)
return the specified parameter as a number in the given alg. field
Definition: algext.cc:1080
naGetDenom
number naGetDenom(number &a, const coeffs cf)
Definition: algext.cc:311
coeffs
naGetNumerator
number naGetNumerator(number &a, const coeffs cf)
Definition: algext.cc:306
naInt
long naInt(number &a, const coeffs cf)
Definition: algext.cc:347
naMult
number naMult(number a, number b, const coeffs cf)
Definition: algext.cc:461
naMapUP
number naMapUP(number a, const coeffs src, const coeffs dst)
Definition: algext.cc:963
naCoeffString
char * naCoeffString(const coeffs r)
Definition: algext.cc:1329
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
naConvFactoryNSingN
number naConvFactoryNSingN(const CanonicalForm n, const coeffs cf)
Definition: algext.cc:752
naPower
void naPower(number a, int exp, number *b, const coeffs cf)
Definition: algext.cc:495
naWriteShort
void naWriteShort(number a, const coeffs cf)
Definition: algext.cc:590
n2pDiv
number n2pDiv(number a, number b, const coeffs cf)
Definition: algext.cc:1550
naKillChar
void naKillChar(coeffs cf)
Definition: algext.cc:1323
n_rep_poly
@ n_rep_poly
(poly), see algext.h
Definition: coeffs.h:114
p_ExtGcdHelper
static poly p_ExtGcdHelper(poly &p, poly &pFactor, poly &q, poly &qFactor, ring r)
Definition: algext.cc:185
n_ParameterNames
static FORCE_INLINE const char ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:809
naInit
number naInit(long i, const coeffs cf)
Definition: algext.cc:341
naRead
const char * naRead(const char *s, number *a, const coeffs cf)
Definition: algext.cc:608
p_Deg
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:579
naSub
number naSub(number a, number b, const coeffs cf)
Definition: algext.cc:450
naNormalize
void naNormalize(number &a, const coeffs cf)
Definition: algext.cc:744
naGenTrans2AlgExt
number naGenTrans2AlgExt(number a, const coeffs cf, const coeffs dst)
Definition: algext.cc:989
naCoeffIsEqual
static BOOLEAN naCoeffIsEqual(const coeffs cf, n_coeffType n, void *param)
Definition: algext.cc:680
n2pCoeffIsEqual
static BOOLEAN n2pCoeffIsEqual(const coeffs cf, n_coeffType n, void *param)
Definition: algext.cc:1575
naIsZero
BOOLEAN naIsZero(number a, const coeffs cf)
Definition: algext.cc:274
m
int m
Definition: cfEzgcd.cc:121
naMapP0
number naMapP0(number a, const coeffs src, const coeffs dst)
Definition: algext.cc:872
assume
#define assume(x)
Definition: mod2.h:390
NULL
#define NULL
Definition: omList.c:10
l
int l
Definition: cfEzgcd.cc:93
R
#define R
Definition: sirandom.c:26
naNeg
number naNeg(number a, const coeffs cf)
this is in-place, modifies a
Definition: algext.cc:334
rSamePolyRep
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
Definition: ring.cc:1668
p
int p
Definition: cfModGcd.cc:4019
naDelete
void naDelete(number *a, const coeffs cf)
Definition: algext.cc:280
naCopyTrans2AlgExt
number naCopyTrans2AlgExt(number a, const coeffs src, const coeffs dst)
Definition: algext.cc:892
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
n_SetMap
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:722
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:26
naIsMOne
BOOLEAN naIsMOne(number a, const coeffs cf)
Definition: algext.cc:325
naEqual
BOOLEAN naEqual(number a, number b, const coeffs cf)
Definition: algext.cc:289
AlgExtInfo::r
ring r
Definition: algext.h:39
n2pRing
#define n2pRing
Definition: algext.cc:1519
naMapZ0
number naMapZ0(number a, const coeffs src, const coeffs dst)
Definition: algext.cc:860
n2pNormalize
void n2pNormalize(number &a, const coeffs cf)
Definition: algext.cc:1535
n_algExt
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition: coeffs.h:36
naMap0P
number naMap0P(number a, const coeffs src, const coeffs dst)
Definition: algext.cc:940
n_rep_gap_gmp
@ n_rep_gap_gmp
(), see rinteger.h, new impl.
Definition: coeffs.h:113