My Project
Loading...
Searching...
No Matches
maps_ip.cc
Go to the documentation of this file.
1/****************************************
2* Computer Algebra System SINGULAR *
3****************************************/
4/*
5* ABSTRACT - the mapping of polynomials to other rings
6*/
7#define TRANSEXT_PRIVATES
8
9#include "kernel/mod2.h"
10
11#include "coeffs/numbers.h"
12#include "coeffs/coeffs.h"
13
16#include "polys/matpol.h"
17#include "polys/prCopy.h"
19
20//#include "polys/ext_fields/longtrans.h"
21// #include "kernel/longalg.h"
22
23#include "misc/options.h"
26
27#include "maps_ip.h"
28#include "ipid.h"
29
30
31#include "lists.h"
32#include "tok.h"
33
34/* debug output: Tok2Cmdname in maApplyFetch*/
35#include "ipshell.h"
36
37/*2
38* maps the expression w to res,
39* switch what: MAP_CMD: use theMap for mapping, N for preimage ring
40* //FETCH_CMD: use pOrdPoly for mapping
41* IMAP_CMD: use perm for mapping, N for preimage ring
42* default: map only poly-structures,
43* use perm and par_perm, N and P,
44*/
45BOOLEAN maApplyFetch(int what,map theMap,leftv res, leftv w, ring preimage_r,
46 int *perm, int *par_perm, int P, nMapFunc nMap)
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<preimage_r->N)&&(perm[i]==0)) i++;
57 if (i<preimage_r->N)
58 {
59 int prev_nonnull=i;
60 i++;
61 for(;i<=preimage_r->N;i++)
62 {
63 if (perm[prev_nonnull] > perm[i])
64 {
66 {
67 Warn("imap not usable for permuting variables, use map (%s <-> %s)", preimage_r->names[prev_nonnull-1],preimage_r->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;
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);
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 (
128 (what==FETCH_CMD) && (preimage_r->cf==currRing->cf)
129#ifdef HAVE_SHIFTBBA
131#endif
132 )
133 res->data=(void *)prCopyR(sBucketPeek((sBucket_pt)data), preimage_r, currRing);
134 else
135 if ( (what==IMAP_CMD) || /*(*/ (what==FETCH_CMD) /*)*/) /* && (nMap!=nCopy)*/
136 res->data=(void *)p_PermPoly(sBucketPeek((sBucket_pt)data),perm,preimage_r,currRing, nMap,par_perm,P,use_mult);
137 else /*if (what==MAP_CMD)*/
138 {
139 res->data=(void*)maMapPoly(sBucketPeek((sBucket_pt)data),preimage_r,(ideal)theMap,currRing,nMap);
140 }
143 break;
144 case POLY_CMD:
145 case VECTOR_CMD:
146 if (
147 (what==FETCH_CMD) && (preimage_r->cf==currRing->cf)
148#ifdef HAVE_SHIFTBBA
150#endif
151 )
152 res->data=(void *)prCopyR( (poly)data, preimage_r, currRing);
153 else
154 if ( (what==IMAP_CMD) || /*(*/ (what==FETCH_CMD) /*)*/) /* && (nMap!=nCopy)*/
155 res->data=(void *)p_PermPoly((poly)data,perm,preimage_r,currRing, nMap,par_perm,P,use_mult);
156 else /*if (what==MAP_CMD)*/
157 {
158 p_Test((poly)data,preimage_r);
159 res->data=(void*)maMapPoly((poly)data,preimage_r,(ideal)theMap,currRing,nMap);
160 }
162 res->data=(void *)p_MinPolyNormalize((poly)res->data, currRing);
163 pTest((poly)res->data);
164 break;
165 case MODUL_CMD:
166 case MATRIX_CMD:
167 case IDEAL_CMD:
168 case MAP_CMD:
169 {
170 int C=((matrix)data)->cols();
171 int R;
172 if (w->rtyp==MAP_CMD) R=1;
173 else R=((matrix)data)->rows();
174 matrix m=mpNew(R,C);
175 char *tmpR=NULL;
176 if(w->rtyp==MAP_CMD)
177 {
178 tmpR=((map)data)->preimage;
179 ((matrix)data)->rank=((matrix)data)->rows();
180 }
181 if (
182 (what==FETCH_CMD) && (preimage_r->cf == currRing->cf)
183#ifdef HAVE_SHIFTBBA
185#endif
186 )
187 {
188 for (i=R*C-1;i>=0;i--)
189 {
190 m->m[i]=prCopyR(((ideal)data)->m[i], preimage_r, currRing);
191 pTest(m->m[i]);
192 }
193 }
194 else if ((what==IMAP_CMD) || (what==FETCH_CMD))
195 {
196 for (i=R*C-1;i>=0;i--)
197 {
198 m->m[i]=p_PermPoly(((ideal)data)->m[i],perm,preimage_r,currRing,
199 nMap,par_perm,P,use_mult);
200 pTest(m->m[i]);
201 }
202 }
203 else /* (what==MAP_CMD) */
204 {
205 assume(what==MAP_CMD);
206 matrix s=mpNew(N,maMaxDeg_Ma((ideal)data,preimage_r));
207 for (i=R*C-1;i>=0;i--)
208 {
209 m->m[i]=maEval(theMap, ((ideal)data)->m[i], preimage_r, nMap, (ideal)s, currRing);
210 pTest(m->m[i]);
211 }
212 idDelete((ideal *)&s);
213 }
214 if(w->rtyp==MAP_CMD)
215 {
216 ((map)data)->preimage=tmpR;
217 ((map)m)->preimage=omStrDup(tmpR);
218 }
219 else
220 {
221 m->rank=((matrix)data)->rank;
222 }
223 res->data=(char *)m;
224 idTest((ideal) m);
225 break;
226 }
227
228 case LIST_CMD:
229 {
230 lists l=(lists)data;
232 ml->Init(l->nr+1);
233 for(i=0;i<=l->nr;i++)
234 {
235 if (((l->m[i].rtyp>BEGIN_RING)&&(l->m[i].rtyp<END_RING))
236 ||(l->m[i].rtyp==LIST_CMD))
237 {
238 if (maApplyFetch(what,theMap,&ml->m[i],&l->m[i],
239 preimage_r,perm,par_perm,P,nMap))
240 {
241 ml->Clean();
243 res->rtyp=0;
244 return TRUE;
245 }
246 }
247 else
248 {
249 ml->m[i].Copy(&l->m[i]);
250 }
251 }
252 res->data=(char *)ml;
253 break;
254 }
255 default:
256 {
257 return TRUE;
258 }
259 }
260 return FALSE;
261}
262
263/*2
264* substitutes the parameter par (from 1..N) by image,
265* does not destroy p and image
266*/
267poly pSubstPar(poly p, int par, poly image)
268{
269 const ring R = currRing->cf->extRing;
270 ideal theMapI = idInit(rPar(currRing),1);
271 nMapFunc nMap = n_SetMap(R->cf, currRing->cf);
272 int i;
273 for(i = rPar(currRing);i>0;i--)
274 {
275 if (i != par)
276 theMapI->m[i-1]= p_NSet(n_Param(i, currRing), currRing);
277 else
278 theMapI->m[i-1] = p_Copy(image, currRing);
279 p_Test(theMapI->m[i-1],currRing);
280 }
281 //iiWriteMatrix((matrix)theMapI,"map:",1,currRing,0);
282
283 map theMap=(map)theMapI;
284 theMap->preimage=NULL;
285
287 sleftv tmpW;
288 poly res=NULL;
289
291 if (currRing->cf->rep==n_rep_rat_fct )
292 {
293 while (p!=NULL)
294 {
295 memset(v,0,sizeof(sleftv));
296
297 number d = n_GetDenom(pGetCoeff(p), currRing->cf);
298 p_Test((poly)NUM((fraction)d), R);
299
300 if ( n_IsOne (d, currRing->cf) )
301 {
302 n_Delete(&d, currRing->cf); d = NULL;
303 }
304 else if (!p_IsConstant((poly)NUM((fraction)d), R))
305 {
306 WarnS("ignoring denominators of coefficients...");
307 n_Delete(&d, currRing->cf); d = NULL;
308 }
309
310 number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
311 memset(&tmpW,0,sizeof(sleftv));
312 tmpW.rtyp = POLY_CMD;
313 p_Test((poly)NUM((fraction)num), R);
314
315 tmpW.data = NUM ((fraction)num); // a copy of this poly will be used
316
317 p_Normalize(NUM((fraction)num),R);
318 if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
319 {
320 WerrorS("map failed");
321 v->data=NULL;
322 }
323 n_Delete(&num, currRing->cf);
324 //TODO check for memory leaks
325 poly pp = pHead(p);
326 //PrintS("map:");pWrite(pp);
327 if( d != NULL )
328 {
329 pSetCoeff(pp, n_Invers(d, currRing->cf));
330 n_Delete(&d, currRing->cf); // d = NULL;
331 }
332 else
333 pSetCoeff(pp, nInit(1));
334
335 //PrintS("->");pWrite((poly)(v->data));
336 poly ppp = pMult((poly)(v->data),pp);
337 //PrintS("->");pWrite(ppp);
338 res=pAdd(res,ppp);
339 pIter(p);
340 }
341 }
342 else if (currRing->cf->rep==n_rep_poly )
343 {
344 while (p!=NULL)
345 {
346 memset(v,0,sizeof(sleftv));
347
348 number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
349 memset(&tmpW,0,sizeof(sleftv));
350 tmpW.rtyp = POLY_CMD;
351 p_Test((poly)num, R);
352
353
354 p_Normalize((poly)num,R);
355 if (num==NULL) num=(number)R->qideal->m[0];
356 tmpW.data = num; // a copy of this poly will be used
357 if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
358 {
359 WerrorS("map failed");
360 v->data=NULL;
361 }
362 if (num!=(number)R->qideal->m[0]) n_Delete(&num, currRing->cf);
363 //TODO check for memory leaks
364 poly pp = pHead(p);
365 //PrintS("map:");pWrite(pp);
366 pSetCoeff(pp,n_Init(1,currRing->cf));
367 //PrintS("cf->");pWrite((poly)(v->data));
368 poly ppp = pMult((poly)(v->data),pp);
369 //PrintS("->");pWrite(ppp);
370 res=pAdd(res,ppp);
371 pIter(p);
372 }
373 }
374 else
375 {
376 WerrorS("cannot apply subst for these coeffcients");
377 }
378 idDelete((ideal *)(&theMap));
380 return res;
381}
382
383/*2
384* substitute the n-th parameter by the poly e in id
385* does not destroy id and e
386*/
387ideal idSubstPar(ideal id, int n, poly e)
388{
389 int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
390 ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
391
392 res->rank = id->rank;
393 for(k--;k>=0;k--)
394 {
395 res->m[k]=pSubstPar(id->m[k],n,e);
396 }
397 return res;
398}
399
400/*2
401* substitutes the variable var (from 1..N) by image,
402* does not destroy p and image
403*/
404poly pSubstPoly(poly p, int var, poly image)
405{
406 if (p==NULL) return NULL;
407#ifdef HAVE_PLURAL
409 {
410 return pSubst(pCopy(p),var,image);
411 }
412#endif
413#ifdef HAVE_SHIFTBBA
414 if (rIsLPRing(currRing))
415 {
416 return pSubst(pCopy(p),var,image);
417 }
418#endif
419 return p_SubstPoly(p,var,image,currRing,currRing,ndCopyMap);
420}
421
422/*2
423* substitute the n-th variable by the poly e in id
424* does not destroy id and e
425*/
426ideal idSubstPoly(ideal id, int n, poly e)
427{
428
429#ifdef HAVE_PLURAL
431 {
432 int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
433 ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
434 res->rank = id->rank;
435 for(k--;k>=0;k--)
436 {
437 res->m[k]=pSubst(pCopy(id->m[k]),n,e);
438 }
439 return res;
440 }
441#endif
442#ifdef HAVE_SHIFTBBA
443 if (rIsLPRing(currRing))
444 {
445 int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
446 ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
447 res->rank = id->rank;
448 for(k--;k>=0;k--)
449 {
450 res->m[k]=pSubst(pCopy(id->m[k]),n,e);
451 }
452 return res;
453 }
454#endif
456}
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
void * ADDRESS
Definition: auxiliary.h:119
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
CanonicalForm num(const CanonicalForm &f)
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
int p
Definition: cfModGcd.cc:4078
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:504
poly * m
Definition: matpol.h:18
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
int rtyp
Definition: subexpr.h:91
void Copy(leftv e)
Definition: subexpr.cc:685
void * data
Definition: subexpr.h:88
Definition: lists.h:24
sleftv * m
Definition: lists.h:46
void Clean(ring r=currRing)
Definition: lists.h:26
INLINE_THIS void Init(int l=0)
Coefficient rings, fields and other domains suitable for Singular polynomials.
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:780
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:600
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:843
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition: numbers.cc:291
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition: coeffs.h:709
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:561
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:697
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:452
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:535
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition: coeffs.h:907
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:605
@ n_rep_poly
(poly), see algext.h
Definition: coeffs.h:113
@ n_rep_rat_fct
(fraction), see transext.h
Definition: coeffs.h:114
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 void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:575
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:465
#define Print
Definition: emacs.cc:80
#define Warn
Definition: emacs.cc:77
#define WarnS
Definition: emacs.cc:78
const CanonicalForm int s
Definition: facAbsFact.cc:51
CanonicalForm res
Definition: facAbsFact.cc:60
const CanonicalForm & w
Definition: facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
void WerrorS(const char *s)
Definition: feFopen.cc:24
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
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
ideal id_SubstPoly(ideal id, int var, poly image, const ring preimage_r, const ring image_r, const nMapFunc nMap)
Definition: subst_maps.cc:71
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
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:140
@ END_RING
Definition: grammar.cc:310
@ IDEAL_CMD
Definition: grammar.cc:284
@ MATRIX_CMD
Definition: grammar.cc:286
@ BUCKET_CMD
Definition: grammar.cc:283
@ IMAP_CMD
Definition: grammar.cc:298
@ MAP_CMD
Definition: grammar.cc:285
@ BEGIN_RING
Definition: grammar.cc:282
@ MODUL_CMD
Definition: grammar.cc:287
@ VECTOR_CMD
Definition: grammar.cc:292
@ NUMBER_CMD
Definition: grammar.cc:288
@ POLY_CMD
Definition: grammar.cc:289
@ FETCH_CMD
Definition: grammar.cc:295
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
#define idTest(id)
Definition: ideals.h:47
EXTERN_VAR omBin sleftv_bin
Definition: ipid.h:145
VAR omBin slists_bin
Definition: lists.cc:23
poly maEval(map theMap, poly p, ring preimage_r, nMapFunc nMap, ideal s, const ring dst_r)
Definition: maps.cc:115
int maMaxDeg_Ma(ideal a, ring preimage_r)
Definition: maps.cc:360
poly p_MinPolyNormalize(poly p, const ring r)
Definition: maps.cc:430
poly pSubstPoly(poly p, int var, poly image)
Definition: maps_ip.cc:404
ideal idSubstPoly(ideal id, int n, poly e)
Definition: maps_ip.cc:426
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
ideal idSubstPar(ideal id, int n, poly e)
Definition: maps_ip.cc:387
poly pSubstPar(poly p, int par, poly image)
Definition: maps_ip.cc:267
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
ip_smatrix * matrix
Definition: matpol.h:43
#define MATROWS(i)
Definition: matpol.h:26
#define MATCOLS(i)
Definition: matpol.h:27
#define assume(x)
Definition: mod2.h:389
#define pIter(p)
Definition: monomials.h:37
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
slists * lists
Definition: mpr_numeric.h:146
#define nInit(i)
Definition: numbers.h:24
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define NULL
Definition: omList.c:12
#define TEST_V_ALLWARN
Definition: options.h:144
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
Definition: p_polys.cc:4027
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:4130
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3813
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition: p_polys.cc:1473
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition: p_polys.h:1962
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:844
#define p_Test(p, r)
Definition: p_polys.h:159
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
#define pAdd(p, q)
Definition: polys.h:203
#define pTest(p)
Definition: polys.h:414
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition: polys.h:31
#define pMult(p, q)
Definition: polys.h:207
#define pSubst(p, n, e)
Definition: polys.h:365
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition: prCopy.cc:34
void PrintS(const char *s)
Definition: reporter.cc:284
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:599
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:411
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define R
Definition: sirandom.c:27
sleftv * leftv
Definition: structs.h:57
@ LIST_CMD
Definition: tok.h:118