Functions
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 380 of file maps_ip.cc.

381 {
382  int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
383  ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
384 
385  res->rank = id->rank;
386  for(k--;k>=0;k--)
387  {
388  res->m[k]=pSubstPar(id->m[k],n,e);
389  }
390  return res;
391 }
int k
Definition: cfEzgcd.cc:92
poly * m
Definition: matpol.h:18
CanonicalForm res
Definition: facAbsFact.cc:64
poly pSubstPar(poly p, int par, poly image)
Definition: maps_ip.cc:260
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
#define MATCOLS(i)
Definition: matpol.h:27
#define MATROWS(i)
Definition: matpol.h:26
long rank
Definition: matpol.h:19

◆ idSubstPoly()

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

Definition at line 413 of file maps_ip.cc.

414 {
415 
416 #ifdef HAVE_PLURAL
417  if (rIsPluralRing(currRing))
418  {
419  int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
420  ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
421  res->rank = id->rank;
422  for(k--;k>=0;k--)
423  {
424  res->m[k]=pSubst(pCopy(id->m[k]),n,e);
425  }
426  return res;
427  }
428 #endif
429  return id_SubstPoly(id,n,e,currRing,currRing,ndCopyMap);
430 }
#define pSubst(p, n, e)
Definition: polys.h:362
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:251
int k
Definition: cfEzgcd.cc:92
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
poly * m
Definition: matpol.h:18
CanonicalForm res
Definition: facAbsFact.cc:64
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:397
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
#define MATCOLS(i)
Definition: matpol.h:27
ideal id_SubstPoly(ideal id, int var, poly image, const ring preimage_r, const ring image_r, const nMapFunc nMap)
Definition: subst_maps.cc:68
#define MATROWS(i)
Definition: matpol.h:26
long rank
Definition: matpol.h:19
#define pCopy(p)
return a copy of the poly
Definition: polys.h:181

◆ 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.

47 {
48  BOOLEAN use_mult=FALSE;
49 #ifdef HAVE_PLURAL
50  if ((what==IMAP_CMD)
52  && rIsPluralRing(preimage_r))
53  {
54  assume(perm!=NULL);
55  int i=1;
56  while((i<currRing->N)&&(perm[i]==0)) i++;
57  if (i<currRing->N)
58  {
59  int prev_nonnull=i;
60  i++;
61  for(;i<=currRing->N;i++)
62  {
63  if (perm[prev_nonnull] > perm[i])
64  {
65  if (TEST_V_ALLWARN)
66  {
67  Warn("imap not usable for permuting variables, use map (%s <-> %s)",currRing->names[prev_nonnull-1],currRing->names[i-1]);
68  }
69  use_mult=TRUE;
70  break;
71  }
72  else
73  prev_nonnull=i;
74  }
75  }
76  }
77 #endif
78  int i;
79  int N = preimage_r->N;
80 #if 0
81  Print("N=%d what=%s ",N,Tok2Cmdname(what));
82  if (perm!=NULL) for(i=1;i<=N;i++) Print("%d -> %d ",i,perm[i]);
83  PrintS("\n");
84  Print("P=%d ",P);
85  if (par_perm!=NULL) for(i=0;i<P;i++) Print("%d -> %d ",i,par_perm[i]);
86  PrintS("\n");
87 #endif
88 
89  void *data=w->Data();
90  res->rtyp = w->rtyp;
91  switch (w->rtyp)
92  {
93  case NUMBER_CMD:
94  if (P!=0)
95  {
96 // poly n_PermNumber(const number z, const int *par_perm, const int OldPar, const ring src, const ring dst);
97  res->data= (void *) n_PermNumber((number)data, par_perm, P, preimage_r, currRing);
98  res->rtyp=POLY_CMD;
99  if (nCoeff_is_algExt(currRing->cf))
100  res->data=(void *)p_MinPolyNormalize((poly)res->data, currRing);
101  pTest((poly) res->data);
102  }
103  else
104  {
105  assume( nMap != NULL );
106  number a = nMap((number)data, preimage_r->cf, currRing->cf);
107  if (nCoeff_is_Extension(currRing->cf))
108  {
109  n_Normalize(a, currRing->cf);
110 /*
111  number a = (number)res->data;
112  number one = nInit(1);
113  number product = nMult(a, one );
114  nDelete(&one);
115  nDelete(&a);
116  res->data=(void *)product;
117  */
118  }
119  #ifdef LDEBUG
120  n_Test(a, currRing->cf);
121  #endif
122  res->data=(void *)a;
123 
124  }
125  break;
126  case BUCKET_CMD:
127  if ((what==FETCH_CMD)&& (preimage_r->cf==currRing->cf))
128  res->data=(void *)prCopyR(sBucketPeek((sBucket_pt)data), preimage_r, currRing);
129  else
130  if ( (what==IMAP_CMD) || /*(*/ (what==FETCH_CMD) /*)*/) /* && (nMap!=nCopy)*/
131  res->data=(void *)p_PermPoly(sBucketPeek((sBucket_pt)data),perm,preimage_r,currRing, nMap,par_perm,P,use_mult);
132  else /*if (what==MAP_CMD)*/
133  {
134  res->data=(void*)maMapPoly(sBucketPeek((sBucket_pt)data),preimage_r,(ideal)theMap,currRing,nMap);
135  }
136  if (nCoeff_is_Extension(currRing->cf))
137  res->data=(void *)p_MinPolyNormalize(sBucketPeek((sBucket_pt)data), currRing);
138  break;
139  case POLY_CMD:
140  case VECTOR_CMD:
141  if ((what==FETCH_CMD)&& (preimage_r->cf==currRing->cf))
142  res->data=(void *)prCopyR( (poly)data, preimage_r, currRing);
143  else
144  if ( (what==IMAP_CMD) || /*(*/ (what==FETCH_CMD) /*)*/) /* && (nMap!=nCopy)*/
145  res->data=(void *)p_PermPoly((poly)data,perm,preimage_r,currRing, nMap,par_perm,P,use_mult);
146  else /*if (what==MAP_CMD)*/
147  {
148  p_Test((poly)data,preimage_r);
149  res->data=(void*)maMapPoly((poly)data,preimage_r,(ideal)theMap,currRing,nMap);
150  }
151  if (nCoeff_is_Extension(currRing->cf))
152  res->data=(void *)p_MinPolyNormalize((poly)res->data, currRing);
153  pTest((poly)res->data);
154  break;
155  case MODUL_CMD:
156  case MATRIX_CMD:
157  case IDEAL_CMD:
158  case MAP_CMD:
159  {
160  int C=((matrix)data)->cols();
161  int R;
162  if (w->rtyp==MAP_CMD) R=1;
163  else R=((matrix)data)->rows();
164  matrix m=mpNew(R,C);
165  char *tmpR=NULL;
166  if(w->rtyp==MAP_CMD)
167  {
168  tmpR=((map)data)->preimage;
169  ((matrix)data)->rank=((matrix)data)->rows();
170  }
171  if ((what==FETCH_CMD)&& (preimage_r->cf == currRing->cf))
172  {
173  for (i=R*C-1;i>=0;i--)
174  {
175  m->m[i]=prCopyR(((ideal)data)->m[i], preimage_r, currRing);
176  pTest(m->m[i]);
177  }
178  }
179  else if ((what==IMAP_CMD) || (what==FETCH_CMD))
180  {
181  for (i=R*C-1;i>=0;i--)
182  {
183  m->m[i]=p_PermPoly(((ideal)data)->m[i],perm,preimage_r,currRing,
184  nMap,par_perm,P,use_mult);
185  pTest(m->m[i]);
186  }
187  }
188  else /* (what==MAP_CMD) */
189  {
190  assume(what==MAP_CMD);
191  matrix s=mpNew(N,maMaxDeg_Ma((ideal)data,preimage_r));
192  for (i=R*C-1;i>=0;i--)
193  {
194  m->m[i]=maEval(theMap, ((ideal)data)->m[i], preimage_r, nMap, (ideal)s, currRing);
195  pTest(m->m[i]);
196  }
197  idDelete((ideal *)&s);
198  }
199  if (nCoeff_is_algExt(currRing->cf))
200  {
201  for (i=R*C-1;i>=0;i--)
202  {
203  m->m[i]=p_MinPolyNormalize(m->m[i], currRing);
204  pTest(m->m[i]);
205  }
206  }
207  if(w->rtyp==MAP_CMD)
208  {
209  ((map)data)->preimage=tmpR;
210  ((map)m)->preimage=omStrDup(tmpR);
211  }
212  else
213  {
214  m->rank=((matrix)data)->rank;
215  }
216  res->data=(char *)m;
217  idTest((ideal) m);
218  break;
219  }
220 
221  case LIST_CMD:
222  {
223  lists l=(lists)data;
225  ml->Init(l->nr+1);
226  for(i=0;i<=l->nr;i++)
227  {
228  if (((l->m[i].rtyp>BEGIN_RING)&&(l->m[i].rtyp<END_RING))
229  ||(l->m[i].rtyp==LIST_CMD))
230  {
231  if (maApplyFetch(what,theMap,&ml->m[i],&l->m[i],
232  preimage_r,perm,par_perm,P,nMap))
233  {
234  ml->Clean();
236  res->rtyp=0;
237  return TRUE;
238  }
239  }
240  else
241  {
242  ml->m[i].Copy(&l->m[i]);
243  }
244  }
245  res->data=(char *)ml;
246  break;
247  }
248  default:
249  {
250  return TRUE;
251  }
252  }
253  return FALSE;
254 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
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:400
const CanonicalForm int s
Definition: facAbsFact.cc:55
sleftv * m
Definition: lists.h:46
#define Print
Definition: emacs.cc:80
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:34
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
Definition: lists.h:23
#define FALSE
Definition: auxiliary.h:96
#define pTest(p)
Definition: polys.h:411
int maMaxDeg_Ma(ideal a, ring preimage_r)
Definition: maps.cc:329
#define TRUE
Definition: auxiliary.h:100
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
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:578
void * ADDRESS
Definition: auxiliary.h:135
VAR omBin slists_bin
Definition: lists.cc:23
void * data
Definition: subexpr.h:88
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
poly * m
Definition: matpol.h:18
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:159
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:4036
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:932
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
#define assume(x)
Definition: mod2.h:390
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:397
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:738
void Copy(leftv e)
Definition: subexpr.cc:714
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
void PrintS(const char *s)
Definition: reporter.cc:284
#define p_Test(p, r)
Definition: p_polys.h:162
INLINE_THIS void Init(int l=0)
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
poly p_MinPolyNormalize(poly p, const ring r)
Definition: maps.cc:399
int nr
Definition: lists.h:44
#define NULL
Definition: omList.c:12
slists * lists
Definition: mpr_numeric.h:146
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
Definition: p_polys.cc:3933
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:140
#define R
Definition: sirandom.c:27
int rtyp
Definition: subexpr.h:91
void Clean(ring r=currRing)
Definition: lists.h:26
void * Data()
Definition: subexpr.cc:1176
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
Definition: tok.h:118
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:868
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
int BOOLEAN
Definition: auxiliary.h:87
#define TEST_V_ALLWARN
Definition: options.h:139
ip_smatrix * matrix
Definition: matpol.h:43
int l
Definition: cfEzgcd.cc:93
poly maEval(map theMap, poly p, ring preimage_r, nMapFunc nMap, ideal s, const ring dst_r)
Definition: maps.cc:115
long rank
Definition: matpol.h:19
#define idTest(id)
Definition: ideals.h:47
#define Warn
Definition: emacs.cc:77
#define omStrDup(s)
Definition: omAllocDecl.h:263

◆ pSubstPar()

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

Definition at line 260 of file maps_ip.cc.

261 {
262  const ring R = currRing->cf->extRing;
263  ideal theMapI = idInit(rPar(currRing),1);
264  nMapFunc nMap = n_SetMap(R->cf, currRing->cf);
265  int i;
266  for(i = rPar(currRing);i>0;i--)
267  {
268  if (i != par)
269  theMapI->m[i-1]= p_NSet(n_Param(i, currRing), currRing);
270  else
271  theMapI->m[i-1] = p_Copy(image, currRing);
272  p_Test(theMapI->m[i-1],currRing);
273  }
274  //iiWriteMatrix((matrix)theMapI,"map:",1,currRing,0);
275 
276  map theMap=(map)theMapI;
277  theMap->preimage=NULL;
278 
280  sleftv tmpW;
281  poly res=NULL;
282 
284  if (currRing->cf->rep==n_rep_rat_fct )
285  {
286  while (p!=NULL)
287  {
288  memset(v,0,sizeof(sleftv));
289 
290  number d = n_GetDenom(pGetCoeff(p), currRing->cf);
291  p_Test((poly)NUM((fraction)d), R);
292 
293  if ( n_IsOne (d, currRing->cf) )
294  {
295  n_Delete(&d, currRing->cf); d = NULL;
296  }
297  else if (!p_IsConstant((poly)NUM((fraction)d), R))
298  {
299  WarnS("ignoring denominators of coefficients...");
300  n_Delete(&d, currRing->cf); d = NULL;
301  }
302 
303  number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
304  memset(&tmpW,0,sizeof(sleftv));
305  tmpW.rtyp = POLY_CMD;
306  p_Test((poly)NUM((fraction)num), R);
307 
308  tmpW.data = NUM ((fraction)num); // a copy of this poly will be used
309 
310  p_Normalize(NUM((fraction)num),R);
311  if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
312  {
313  WerrorS("map failed");
314  v->data=NULL;
315  }
316  n_Delete(&num, currRing->cf);
317  //TODO check for memory leaks
318  poly pp = pHead(p);
319  //PrintS("map:");pWrite(pp);
320  if( d != NULL )
321  {
322  pSetCoeff(pp, n_Invers(d, currRing->cf));
323  n_Delete(&d, currRing->cf); // d = NULL;
324  }
325  else
326  pSetCoeff(pp, nInit(1));
327 
328  //PrintS("->");pWrite((poly)(v->data));
329  poly ppp = pMult((poly)(v->data),pp);
330  //PrintS("->");pWrite(ppp);
331  res=pAdd(res,ppp);
332  pIter(p);
333  }
334  }
335  else if (currRing->cf->rep==n_rep_poly )
336  {
337  while (p!=NULL)
338  {
339  memset(v,0,sizeof(sleftv));
340 
341  number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
342  memset(&tmpW,0,sizeof(sleftv));
343  tmpW.rtyp = POLY_CMD;
344  p_Test((poly)num, R);
345 
346 
347  p_Normalize((poly)num,R);
348  if (num==NULL) num=(number)R->qideal->m[0];
349  tmpW.data = num; // a copy of this poly will be used
350  if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
351  {
352  WerrorS("map failed");
353  v->data=NULL;
354  }
355  if (num!=(number)R->qideal->m[0]) n_Delete(&num, currRing->cf);
356  //TODO check for memory leaks
357  poly pp = pHead(p);
358  //PrintS("map:");pWrite(pp);
359  pSetCoeff(pp,n_Init(1,currRing->cf));
360  //PrintS("cf->");pWrite((poly)(v->data));
361  poly ppp = pMult((poly)(v->data),pp);
362  //PrintS("->");pWrite(ppp);
363  res=pAdd(res,ppp);
364  pIter(p);
365  }
366  }
367  else
368  {
369  WerrorS("cannot apply subst for these coeffcients");
370  }
371  idDelete((ideal *)(&theMap));
373  return res;
374 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
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:400
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:608
Class used for (list of) interpreter objects.
Definition: subexpr.h:82
#define pAdd(p, q)
Definition: polys.h:199
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
EXTERN_VAR omBin sleftv_bin
Definition: ipid.h:140
CanonicalForm num(const CanonicalForm &f)
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:468
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:594
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1455
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:538
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
void * ADDRESS
Definition: auxiliary.h:135
sleftv * leftv
Definition: structs.h:62
void WerrorS(const char *s)
Definition: feFopen.cc:24
(fraction), see transext.h
Definition: coeffs.h:114
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
#define WarnS
Definition: emacs.cc:78
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:811
(poly), see algext.h
Definition: coeffs.h:113
void * data
Definition: subexpr.h:88
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..n_NumberOfParameters(...)
Definition: coeffs.h:805
#define pIter(p)
Definition: monomials.h:37
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
if(yy_init)
Definition: libparse.cc:1420
CanonicalForm res
Definition: facAbsFact.cc:64
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1931
CanonicalForm pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:248
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:564
int i
Definition: cfEzgcd.cc:125
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
Definition: polys.h:67
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
#define p_Test(p, r)
Definition: p_polys.h:162
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3732
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:12
#define pMult(p, q)
Definition: polys.h:203
#define R
Definition: sirandom.c:27
int rtyp
Definition: subexpr.h:91
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:603
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455
int p
Definition: cfModGcd.cc:4019
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define nInit(i)
Definition: numbers.h:24
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition: polys.h:31

◆ pSubstPoly()

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

Definition at line 397 of file maps_ip.cc.

398 {
399  if (p==NULL) return NULL;
400 #ifdef HAVE_PLURAL
401  if (rIsPluralRing(currRing))
402  {
403  return pSubst(pCopy(p),var,image);
404  }
405 #endif
406  return p_SubstPoly(p,var,image,currRing,currRing,ndCopyMap);
407 }
#define pSubst(p, n, e)
Definition: polys.h:362
number ndCopyMap(number a, const coeffs aRing, const coeffs r)
Definition: numbers.cc:251
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:39
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:397
#define NULL
Definition: omList.c:12
int p
Definition: cfModGcd.cc:4019
#define pCopy(p)
return a copy of the poly
Definition: polys.h:181