Loading...
Searching...
No Matches
maps_ip.h File Reference
`#include "kernel/mod2.h"`
`#include "polys/matpol.h"`
`#include "kernel/structs.h"`
`#include "kernel/ideals.h"`
`#include "kernel/polys.h"`

Go to the source code of this file.

## Functions

poly | pSubstPoly (poly p, int var, poly image)
poly | pSubstPar (poly p, int par, poly image)
ideal | idSubstPoly (ideal id, int n, poly e)
ideal | idSubstPar (ideal id, int n, poly e)
BOOLEAN | maApplyFetch (int what, map theMap, leftv res, leftv w, ring preimage_r, int *perm, int *par_perm, int P, nMapFunc nMap)

## Function Documentation

## idSubstPar()

ideal idSubstPar | ( | ideal | id,
|  | int | n,
|  | poly | e )

Definition at line 386 of file maps_ip.cc.

{
int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
res->rank = id->rank;
for(k--;k>=0;k--)
{
res->m[k]=pSubstPar(id->m[k],n,e);
}
return res;
}
k
int k
Definition cfEzgcd.cc:99
ip_smatrix::m
poly * m
Definition matpol.h:18
res
CanonicalForm res
Definition facAbsFact.cc:60
pSubstPar
poly pSubstPar(poly p, int par, poly image)
Definition maps_ip.cc:266
mpNew
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition matpol.cc:37
matrix
ip_smatrix * matrix
Definition matpol.h:43
MATROWS
#define MATROWS(i)
Definition matpol.h:26
MATCOLS
#define MATCOLS(i)
Definition matpol.h:27

## idSubstPoly()

ideal idSubstPoly | ( | ideal | id,
|  | int | n,
|  | poly | e )

Definition at line 425 of file maps_ip.cc.

{
#ifdef HAVE_PLURAL
if (rIsPluralRing(currRing))
{
int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
res->rank = id->rank;
for(k--;k>=0;k--)
{
res->m[k]=pSubst(pCopy(id->m[k]),n,e);
}
return res;
}
#endif
#ifdef HAVE_SHIFTBBA
if (rIsLPRing(currRing))
{
int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
res->rank = id->rank;
for(k--;k>=0;k--)
{
res->m[k]=pSubst(pCopy(id->m[k]),n,e);
}
return res;
}
#endif
return id_SubstPoly(id,n,e,currRing,currRing,ndCopyMap);
}
ndCopyMap
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition numbers.cc:293
id_SubstPoly
ideal id_SubstPoly(ideal id, int var, poly image, const ring preimage_r, const ring image_r, const nMapFunc nMap)
Definition subst_maps.cc:78
currRing
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
pSubst
#define pSubst(p, n, e)
Definition polys.h:366
pCopy
#define pCopy(p)
return a copy of the poly
Definition polys.h:186
rIsPluralRing
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406
rIsLPRing
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:417

## maApplyFetch()

BOOLEAN maApplyFetch | ( | int | what,
|  | map | theMap,
|  | leftv | res,
|  | leftv | w,
|  | ring | preimage_r,
|  | int * | perm,
|  | int * | par_perm,
|  | int | P,
|  | nMapFunc | nMap )

Definition at line 45 of file maps_ip.cc.

{
BOOLEAN use_mult=FALSE;
#ifdef HAVE_PLURAL
if ((what==IMAP_CMD)
&& rIsPluralRing(currRing)
&& rIsPluralRing(preimage_r))
{
assume(perm!=NULL);
int i=1;
while((i<preimage_r->N)&&(perm[i]==0)) i++;
if (i<preimage_r->N)
{
int prev_nonnull=i;
i++;
for(;i<=preimage_r->N;i++)
{
if (perm[prev_nonnull] > perm[i])
{
if (TEST_V_ALLWARN)
{
Warn("imap not usable for permuting variables, use map (%s <-> %s)", preimage_r->names[prev_nonnull-1],preimage_r->names[i-1]);
}
use_mult=TRUE;
break;
}
else
prev_nonnull=i;
}
}
}
#endif
int i;
int N = preimage_r->N;
#if 0
Print("N=%d what=%s ",N,Tok2Cmdname(what));
if (perm!=NULL) for(i=1;i<=N;i++) Print("%d -> %d ",i,perm[i]);
PrintS("\n");
Print("P=%d ",P);
if (par_perm!=NULL) for(i=0;i<P;i++) Print("%d -> %d ",i,par_perm[i]);
PrintS("\n");
#endif
void *data=w->Data();
res->rtyp = w->rtyp;
switch (w->rtyp)
{
case NUMBER_CMD:
if (P!=0)
{
// poly n_PermNumber(const number z, const int *par_perm, const int OldPar, const ring src, const ring dst);
res->data= (void *) n_PermNumber((number)data, par_perm, P, preimage_r, currRing);
res->rtyp=POLY_CMD;
if (nCoeff_is_algExt(currRing->cf))
res->data=(void *)p_MinPolyNormalize((poly)res->data, currRing);
pTest((poly) res->data);
}
else
{
assume( nMap != NULL );
number a = nMap((number)data, preimage_r->cf, currRing->cf);
if (nCoeff_is_Extension(currRing->cf))
{
n_Normalize(a, currRing->cf);
/*
number a = (number)res->data;
number one = nInit(1);
number product = nMult(a, one );
nDelete(&one);
nDelete(&a);
res->data=(void *)product;
*/
}
#ifdef LDEBUG
n_Test(a, currRing->cf);
#endif
res->data=(void *)a;
}
break;
case BUCKET_CMD:
if (
(what==FETCH_CMD) && (preimage_r->cf==currRing->cf)
#ifdef HAVE_SHIFTBBA
&& !rIsLPRing(currRing)
#endif
)
res->data=(void *)prCopyR(sBucketPeek((sBucket_pt)data), preimage_r, currRing);
else
if ( (what==IMAP_CMD) || /*(*/ (what==FETCH_CMD) /*)*/) /* && (nMap!=nCopy)*/
res->data=(void *)p_PermPoly(sBucketPeek((sBucket_pt)data),perm,preimage_r,currRing, nMap,par_perm,P,use_mult);
else /*if (what==MAP_CMD)*/
{
res->data=(void*)maMapPoly(sBucketPeek((sBucket_pt)data),preimage_r,(ideal)theMap,currRing,nMap);
}
if (nCoeff_is_Extension(currRing->cf))
res->data=(void *)p_MinPolyNormalize(sBucketPeek((sBucket_pt)data), currRing);
break;
case POLY_CMD:
case VECTOR_CMD:
if (
(what==FETCH_CMD) && (preimage_r->cf==currRing->cf)
#ifdef HAVE_SHIFTBBA
&& !rIsLPRing(currRing)
#endif
)
res->data=(void *)prCopyR( (poly)data, preimage_r, currRing);
else
if ( (what==IMAP_CMD) || /*(*/ (what==FETCH_CMD) /*)*/) /* && (nMap!=nCopy)*/
res->data=(void *)p_PermPoly((poly)data,perm,preimage_r,currRing, nMap,par_perm,P,use_mult);
else /*if (what==MAP_CMD)*/
{
p_Test((poly)data,preimage_r);
res->data=(void*)maMapPoly((poly)data,preimage_r,(ideal)theMap,currRing,nMap);
}
if (nCoeff_is_Extension(currRing->cf))
res->data=(void *)p_MinPolyNormalize((poly)res->data, currRing);
pTest((poly)res->data);
break;
case MODUL_CMD:
case MATRIX_CMD:
case IDEAL_CMD:
case MAP_CMD:
case SMATRIX_CMD:
{
int C=((matrix)data)->cols();
int R;
matrix m=NULL;
if (w->rtyp==MAP_CMD) R=1;
else R=((matrix)data)->rows();
char *tmpR=NULL;
if(w->rtyp==MAP_CMD)
{
tmpR=((map)data)->preimage;
((matrix)data)->rank=((matrix)data)->rows();
}
if (
(what==FETCH_CMD) && (preimage_r->cf == currRing->cf)
#ifdef HAVE_SHIFTBBA
&& !rIsLPRing(currRing)
#endif
)
{
m=mpNew(R,C);
for (i=R*C-1;i>=0;i--)
{
m->m[i]=prCopyR(((ideal)data)->m[i], preimage_r, currRing);
pTest(m->m[i]);
}
}
else if ((what==IMAP_CMD) || (what==FETCH_CMD))
{
m=(matrix)id_PermIdeal((ideal)data,R,C,perm,preimage_r,currRing,
nMap,par_perm,P,use_mult);
}
else /* (what==MAP_CMD) */
{
assume(what==MAP_CMD);
m=mpNew(R,C);
matrix s=mpNew(N,maMaxDeg_Ma((ideal)data,preimage_r));
for (i=R*C-1;i>=0;i--)
{
m->m[i]=maEval(theMap, ((ideal)data)->m[i], preimage_r, nMap, (ideal)s, currRing);
pTest(m->m[i]);
}
idDelete((ideal *)&s);
}
if(w->rtyp==MAP_CMD)
{
((map)data)->preimage=tmpR;
((map)m)->preimage=omStrDup(tmpR);
}
else
{
m->rank=((matrix)data)->rank;
}
res->data=(char *)m;
idTest((ideal) m);
break;
}
case LIST_CMD:
{
lists l=(lists)data;
lists ml=(lists)omAllocBin(slists_bin);
ml->Init(l->nr+1);
for(i=0;i<=l->nr;i++)
{
if (((l->m[i].rtyp>BEGIN_RING)&&(l->m[i].rtyp<END_RING))
||(l->m[i].rtyp==LIST_CMD))
{
if (maApplyFetch(what,theMap,&ml->m[i],&l->m[i],
preimage_r,perm,par_perm,P,nMap))
{
ml->Clean();
omFreeBin((ADDRESS)ml, slists_bin);
res->rtyp=0;
return TRUE;
}
}
else
{
ml->m[i].Copy(&l->m[i]);
}
}
res->data=(char *)ml;
break;
}
default:
{
return TRUE;
}
}
return FALSE;
}
BOOLEAN
int BOOLEAN
Definition auxiliary.h:88
TRUE
#define TRUE
Definition auxiliary.h:101
FALSE
#define FALSE
Definition auxiliary.h:97
ADDRESS
void * ADDRESS
Definition auxiliary.h:120
N
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
l
int l
Definition cfEzgcd.cc:100
m
int m
Definition cfEzgcd.cc:128
i
int i
Definition cfEzgcd.cc:132
map
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
Definition cf_map_ext.cc:505
sleftv::Copy
void Copy(leftv e)
Definition subexpr.cc:689
slists::m
sleftv * m
Definition lists.h:46
slists::Clean
void Clean(ring r=currRing)
Definition lists.h:26
slists::Init
INLINE_THIS void Init(int l=0)
nCoeff_is_Extension
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition coeffs.h:841
n_Test
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r).
Definition coeffs.h:715
nCoeff_is_algExt
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition coeffs.h:905
n_Normalize
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition coeffs.h:581
Print
#define Print
Definition emacs.cc:80
Warn
#define Warn
Definition emacs.cc:77
s
const CanonicalForm int s
Definition facAbsFact.cc:51
w
const CanonicalForm & w
Definition facAbsFact.cc:51
maMapPoly
poly maMapPoly(const poly map_p, const ring map_r, const ideal image_id, const ring image_r, const nMapFunc nMap)
polynomial map for poly (vector) map_p: the poly (vector) to map map_r: the base ring for map_p image...
Definition gen_maps.cc:166
Tok2Cmdname
const char * Tok2Cmdname(int tok)
Definition gentable.cc:137
END_RING
@ END_RING
Definition grammar.cc:311
IDEAL_CMD
@ IDEAL_CMD
Definition grammar.cc:285
MATRIX_CMD
@ MATRIX_CMD
Definition grammar.cc:287
BUCKET_CMD
@ BUCKET_CMD
Definition grammar.cc:284
IMAP_CMD
@ IMAP_CMD
Definition grammar.cc:299
MAP_CMD
@ MAP_CMD
Definition grammar.cc:286
BEGIN_RING
@ BEGIN_RING
Definition grammar.cc:283
MODUL_CMD
@ MODUL_CMD
Definition grammar.cc:288
SMATRIX_CMD
@ SMATRIX_CMD
Definition grammar.cc:292
VECTOR_CMD
@ VECTOR_CMD
Definition grammar.cc:293
NUMBER_CMD
@ NUMBER_CMD
Definition grammar.cc:289
POLY_CMD
@ POLY_CMD
Definition grammar.cc:290
FETCH_CMD
@ FETCH_CMD
Definition grammar.cc:296
idDelete
#define idDelete(H)
delete an ideal
Definition ideals.h:29
idTest
#define idTest(id)
Definition ideals.h:47
slists_bin
VAR omBin slists_bin
Definition lists.cc:23
maEval
poly maEval(map theMap, poly p, ring preimage_r, nMapFunc nMap, ideal s, const ring dst_r)
Definition maps.cc:117
maMaxDeg_Ma
int maMaxDeg_Ma(ideal a, ring preimage_r)
Definition maps.cc:352
p_MinPolyNormalize
poly p_MinPolyNormalize(poly p, const ring r)
Definition maps.cc:422
maApplyFetch
BOOLEAN maApplyFetch(int what, map theMap, leftv res, leftv w, ring preimage_r, int *perm, int *par_perm, int P, nMapFunc nMap)
Definition maps_ip.cc:45
assume
#define assume(x)
Definition mod2.h:389
lists
slists * lists
Definition mpr_numeric.h:146
omStrDup
#define omStrDup(s)
Definition omAllocDecl.h:263
omAllocBin
#define omAllocBin(bin)
Definition omAllocDecl.h:205
omFreeBin
#define omFreeBin(addr, bin)
Definition omAllocDecl.h:259
NULL
#define NULL
Definition omList.c:12
TEST_V_ALLWARN
#define TEST_V_ALLWARN
Definition options.h:145
n_PermNumber
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
Definition p_polys.cc:4153
p_PermPoly
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition p_polys.cc:4256
p_Test
#define p_Test(p, r)
Definition p_polys.h:161
pTest
#define pTest(p)
Definition polys.h:415
prCopyR
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition prCopy.cc:34
PrintS
void PrintS(const char *s)
Definition reporter.cc:288
sBucketPeek
poly sBucketPeek(sBucket_pt b)
Definition sbuckets.cc:455
sBucket_pt
sBucket * sBucket_pt
Definition sbuckets.h:16
id_PermIdeal
ideal id_PermIdeal(ideal I, int R, int C, const int *perm, const ring src, const ring dst, nMapFunc nMap, const int *par_perm, int P, BOOLEAN use_mult)
mapping ideals/matrices to other rings
Definition simpleideals.cc:2219
R
#define R
Definition sirandom.c:27
LIST_CMD
@ LIST_CMD
Definition tok.h:118

## pSubstPar()

poly pSubstPar | ( | poly | p,
|  | int | par,
|  | poly | image )

Definition at line 266 of file maps_ip.cc.

{
const ring R = currRing->cf->extRing;
ideal theMapI = idInit(rPar(currRing),1);
nMapFunc nMap = n_SetMap(R->cf, currRing->cf);
int i;
for(i = rPar(currRing);i>0;i--)
{
if (i != par)
theMapI->m[i-1]= p_NSet(n_Param(i, currRing), currRing);
else
theMapI->m[i-1] = p_Copy(image, currRing);
p_Test(theMapI->m[i-1],currRing);
}
//iiWriteMatrix((matrix)theMapI,"map:",1,currRing,0);
map theMap=(map)theMapI;
theMap->preimage=NULL;
leftv v=(leftv)omAllocBin(sleftv_bin);
sleftv tmpW;
poly res=NULL;
p_Normalize(p,currRing);
if (currRing->cf->rep==n_rep_rat_fct )
{
while (p!=NULL)
{
memset(v,0,sizeof(sleftv));
number d = n_GetDenom(pGetCoeff(p), currRing->cf);
p_Test((poly)NUM((fraction)d), R);
if ( n_IsOne (d, currRing->cf) )
{
n_Delete(&d, currRing->cf); d = NULL;
}
else if (!p_IsConstant((poly)NUM((fraction)d), R))
{
WarnS("ignoring denominators of coefficients...");
n_Delete(&d, currRing->cf); d = NULL;
}
number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
memset(&tmpW,0,sizeof(sleftv));
tmpW.rtyp = POLY_CMD;
p_Test((poly)NUM((fraction)num), R);
tmpW.data = NUM ((fraction)num); // a copy of this poly will be used
p_Normalize(NUM((fraction)num),R);
if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
{
WerrorS("map failed");
v->data=NULL;
}
n_Delete(&num, currRing->cf);
//TODO check for memory leaks
poly pp = pHead(p);
//PrintS("map:");pWrite(pp);
if( d != NULL )
{
pSetCoeff(pp, n_Invers(d, currRing->cf));
n_Delete(&d, currRing->cf); // d = NULL;
}
else
pSetCoeff(pp, nInit(1));
//PrintS("->");pWrite((poly)(v->data));
poly ppp = pMult((poly)(v->data),pp);
//PrintS("->");pWrite(ppp);
res=pAdd(res,ppp);
pIter(p);
}
}
else if (currRing->cf->rep==n_rep_poly )
{
while (p!=NULL)
{
memset(v,0,sizeof(sleftv));
number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
memset(&tmpW,0,sizeof(sleftv));
tmpW.rtyp = POLY_CMD;
p_Test((poly)num, R);
p_Normalize((poly)num,R);
if (num==NULL) num=(number)R->qideal->m[0];
tmpW.data = num; // a copy of this poly will be used
if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
{
WerrorS("map failed");
v->data=NULL;
}
if (num!=(number)R->qideal->m[0]) n_Delete(&num, currRing->cf);
//TODO check for memory leaks
poly pp = pHead(p);
//PrintS("map:");pWrite(pp);
pSetCoeff(pp,n_Init(1,currRing->cf));
//PrintS("cf->");pWrite((poly)(v->data));
poly ppp = pMult((poly)(v->data),pp);
//PrintS("->");pWrite(ppp);
res=pAdd(res,ppp);
pIter(p);
}
}
else
{
WerrorS("cannot apply subst for these coefficients");
}
idDelete((ideal *)(&theMap));
omFreeBin((ADDRESS)v, sleftv_bin);
return res;
}
pp
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f ).
Definition cf_gcd.cc:676
num
CanonicalForm num(const CanonicalForm &f)
Definition canonicalform.h:337
p
int p
Definition cfModGcd.cc:4086
sleftv
Class used for (list of) interpreter objects.
Definition subexpr.h:83
sleftv::rtyp
int rtyp
Definition subexpr.h:91
sleftv::data
void * data
Definition subexpr.h:88
n_Param
static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1....
Definition coeffs.h:778
n_GetDenom
static FORCE_INLINE number n_GetDenom(number &n, const coeffs r)
return the denominator of n (if elements of r are by nature not fractional, result is 1)
Definition coeffs.h:606
n_Invers
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible
Definition coeffs.h:567
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:703
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:461
n_Init
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition coeffs.h:541
n_GetNumerator
static FORCE_INLINE number n_GetNumerator(number &n, const coeffs r)
return the numerator of n (if elements of r are by nature not fractional, result is n)
Definition coeffs.h:611
n_rep_poly
@ n_rep_poly
(poly), see algext.h
Definition coeffs.h:120
n_rep_rat_fct
@ n_rep_rat_fct
(fraction), see transext.h
Definition coeffs.h:121
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
n_IsOne
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:474
WarnS
#define WarnS
Definition emacs.cc:78
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
WerrorS
void WerrorS(const char *s)
Definition feFopen.cc:24
sleftv_bin
EXTERN_VAR omBin sleftv_bin
Definition ipid.h:145
pIter
#define pIter(p)
Definition monomials.h:37
pGetCoeff
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
nInit
#define nInit(i)
Definition numbers.h:24
p_Normalize
void p_Normalize(poly p, const ring r)
Definition p_polys.cc:3939
p_NSet
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition p_polys.cc:1474
p_IsConstant
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1985
p_Copy
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:848
pAdd
#define pAdd(p, q)
Definition polys.h:204
pHead
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition polys.h:68
pSetCoeff
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition polys.h:32
pMult
#define pMult(p, q)
Definition polys.h:208
NUM
#define NUM
Definition readcf.cc:180
rPar
static int rPar(const ring r)
(r->cf->P)
Definition ring.h:605
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition simpleideals.cc:35
leftv
sleftv * leftv
Definition structs.h:53

## pSubstPoly()

poly pSubstPoly | ( | poly | p,
|  | int | var,
|  | poly | image )

Definition at line 403 of file maps_ip.cc.

{
if (p==NULL) return NULL;
#ifdef HAVE_PLURAL
if (rIsPluralRing(currRing))
{
return pSubst(pCopy(p),var,image);
}
#endif
#ifdef HAVE_SHIFTBBA
if (rIsLPRing(currRing))
{
return pSubst(pCopy(p),var,image);
}
#endif
return p_SubstPoly(p,var,image,currRing,currRing,ndCopyMap);
}
p_SubstPoly
poly p_SubstPoly(poly p, int var, poly image, const ring preimage_r, const ring image_r, const nMapFunc nMap, matrix cache=NULL)
Definition subst_maps.cc:46