My Project  UNKNOWN_GIT_VERSION
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 1683 of file algext.cc.

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

◆ naCoeffName()

char* naCoeffName ( const coeffs  r)

Definition at line 1356 of file algext.cc.

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

◆ naCoeffString()

char* naCoeffString ( const coeffs  r)

Definition at line 1333 of file algext.cc.

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

◆ naInitChar()

BOOLEAN naInitChar ( coeffs  cf,
void *  infoStruct 
)

Initialize the coeffs object.

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

Definition at line 1399 of file algext.cc.

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

◆ 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:421
n_rep_gap_rat
@ n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:111
FALSE
#define FALSE
Definition: auxiliary.h:94
n2pCoeffString
char * n2pCoeffString(const coeffs cf)
Definition: algext.cc:1599
nCoeff_is_Zp
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:822
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:576
naIsOne
BOOLEAN naIsOne(number a, const coeffs cf)
Definition: algext.cc:317
naCoeffName
char * naCoeffName(const coeffs r)
Definition: algext.cc:1356
n2pCoeffWrite
void n2pCoeffWrite(const coeffs cf, BOOLEAN details)
Definition: algext.cc:1655
n2pRead
const char * n2pRead(const char *s, number *a, const coeffs cf)
Definition: algext.cc:1570
n2pPower
void n2pPower(number a, int exp, number *b, const coeffs cf)
Definition: algext.cc:1563
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:4554
n2pInvers
number n2pInvers(number a, const coeffs cf)
Definition: algext.cc:1667
naChineseRemainder
number naChineseRemainder(number *x, number *q, int rl, BOOLEAN, CFArray &inv_cache, const coeffs cf)
Definition: algext.cc:1379
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:1391
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:851
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:252
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:164
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:796
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:1546
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:828
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:813
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:582
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:73
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
rRingVar
static char * rRingVar(short i, const ring r)
Definition: ring.h:567
naRing
#define naRing
Definition: algext.cc:63
naClearDenominators
void naClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition: algext.cc:1311
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:1627
h
static Poly * h
Definition: janet.cc:972
naClearContent
static void naClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs cf)
Definition: algext.cc:1106
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:1333
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:1554
naKillChar
void naKillChar(coeffs cf)
Definition: algext.cc:1327
n_rep_poly
@ n_rep_poly
(poly), see algext.h
Definition: coeffs.h:113
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:800
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:1579
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:1683
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:721
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:1523
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:1539
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:112