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++;
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 matrix m=NULL;
173 if (w->rtyp==MAP_CMD) R=1;
174 else R=((matrix)data)->rows();
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 m=mpNew(R,C);
189 for (i=R*C-1;i>=0;i--)
190 {
191 m->m[i]=prCopyR(((ideal)data)->m[i], preimage_r, currRing);
192 pTest(m->m[i]);
193 }
194 }
195 else if ((what==IMAP_CMD) || (what==FETCH_CMD))
196 {
197 m=(matrix)id_PermIdeal((ideal)data,R,C,perm,preimage_r,currRing,
198 nMap,par_perm,P,use_mult);
199 }
200 else /* (what==MAP_CMD) */
201 {
202 assume(what==MAP_CMD);
203 m=mpNew(R,C);
204 matrix s=mpNew(N,maMaxDeg_Ma((ideal)data,preimage_r));
205 for (i=R*C-1;i>=0;i--)
206 {
207 m->m[i]=maEval(theMap, ((ideal)data)->m[i], preimage_r, nMap, (ideal)s, currRing);
208 pTest(m->m[i]);
209 }
210 idDelete((ideal *)&s);
211 }
212 if(w->rtyp==MAP_CMD)
213 {
214 ((map)data)->preimage=tmpR;
215 ((map)m)->preimage=omStrDup(tmpR);
216 }
217 else
218 {
219 m->rank=((matrix)data)->rank;
220 }
221 res->data=(char *)m;
222 idTest((ideal) m);
223 break;
224 }
225
226 case LIST_CMD:
227 {
228 lists l=(lists)data;
230 ml->Init(l->nr+1);
231 for(i=0;i<=l->nr;i++)
232 {
233 if (((l->m[i].rtyp>BEGIN_RING)&&(l->m[i].rtyp<END_RING))
234 ||(l->m[i].rtyp==LIST_CMD))
235 {
236 if (maApplyFetch(what,theMap,&ml->m[i],&l->m[i],
237 preimage_r,perm,par_perm,P,nMap))
238 {
239 ml->Clean();
241 res->rtyp=0;
242 return TRUE;
243 }
244 }
245 else
246 {
247 ml->m[i].Copy(&l->m[i]);
248 }
249 }
250 res->data=(char *)ml;
251 break;
252 }
253 default:
254 {
255 return TRUE;
256 }
257 }
258 return FALSE;
259}
260
261/*2
262* substitutes the parameter par (from 1..N) by image,
263* does not destroy p and image
264*/
265poly pSubstPar(poly p, int par, poly image)
266{
267 const ring R = currRing->cf->extRing;
268 ideal theMapI = idInit(rPar(currRing),1);
269 nMapFunc nMap = n_SetMap(R->cf, currRing->cf);
270 int i;
271 for(i = rPar(currRing);i>0;i--)
272 {
273 if (i != par)
274 theMapI->m[i-1]= p_NSet(n_Param(i, currRing), currRing);
275 else
276 theMapI->m[i-1] = p_Copy(image, currRing);
277 p_Test(theMapI->m[i-1],currRing);
278 }
279 //iiWriteMatrix((matrix)theMapI,"map:",1,currRing,0);
280
281 map theMap=(map)theMapI;
282 theMap->preimage=NULL;
283
285 sleftv tmpW;
286 poly res=NULL;
287
289 if (currRing->cf->rep==n_rep_rat_fct )
290 {
291 while (p!=NULL)
292 {
293 memset(v,0,sizeof(sleftv));
294
295 number d = n_GetDenom(pGetCoeff(p), currRing->cf);
296 p_Test((poly)NUM((fraction)d), R);
297
298 if ( n_IsOne (d, currRing->cf) )
299 {
300 n_Delete(&d, currRing->cf); d = NULL;
301 }
302 else if (!p_IsConstant((poly)NUM((fraction)d), R))
303 {
304 WarnS("ignoring denominators of coefficients...");
305 n_Delete(&d, currRing->cf); d = NULL;
306 }
307
308 number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
309 memset(&tmpW,0,sizeof(sleftv));
310 tmpW.rtyp = POLY_CMD;
311 p_Test((poly)NUM((fraction)num), R);
312
313 tmpW.data = NUM ((fraction)num); // a copy of this poly will be used
314
315 p_Normalize(NUM((fraction)num),R);
316 if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
317 {
318 WerrorS("map failed");
319 v->data=NULL;
320 }
321 n_Delete(&num, currRing->cf);
322 //TODO check for memory leaks
323 poly pp = pHead(p);
324 //PrintS("map:");pWrite(pp);
325 if( d != NULL )
326 {
327 pSetCoeff(pp, n_Invers(d, currRing->cf));
328 n_Delete(&d, currRing->cf); // d = NULL;
329 }
330 else
331 pSetCoeff(pp, nInit(1));
332
333 //PrintS("->");pWrite((poly)(v->data));
334 poly ppp = pMult((poly)(v->data),pp);
335 //PrintS("->");pWrite(ppp);
336 res=pAdd(res,ppp);
337 pIter(p);
338 }
339 }
340 else if (currRing->cf->rep==n_rep_poly )
341 {
342 while (p!=NULL)
343 {
344 memset(v,0,sizeof(sleftv));
345
346 number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
347 memset(&tmpW,0,sizeof(sleftv));
348 tmpW.rtyp = POLY_CMD;
349 p_Test((poly)num, R);
350
351
352 p_Normalize((poly)num,R);
353 if (num==NULL) num=(number)R->qideal->m[0];
354 tmpW.data = num; // a copy of this poly will be used
355 if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
356 {
357 WerrorS("map failed");
358 v->data=NULL;
359 }
360 if (num!=(number)R->qideal->m[0]) n_Delete(&num, currRing->cf);
361 //TODO check for memory leaks
362 poly pp = pHead(p);
363 //PrintS("map:");pWrite(pp);
364 pSetCoeff(pp,n_Init(1,currRing->cf));
365 //PrintS("cf->");pWrite((poly)(v->data));
366 poly ppp = pMult((poly)(v->data),pp);
367 //PrintS("->");pWrite(ppp);
368 res=pAdd(res,ppp);
369 pIter(p);
370 }
371 }
372 else
373 {
374 WerrorS("cannot apply subst for these coefficients");
375 }
376 idDelete((ideal *)(&theMap));
378 return res;
379}
380
381/*2
382* substitute the n-th parameter by the poly e in id
383* does not destroy id and e
384*/
385ideal idSubstPar(ideal id, int n, poly e)
386{
387 int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
388 ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
389
390 res->rank = id->rank;
391 for(k--;k>=0;k--)
392 {
393 res->m[k]=pSubstPar(id->m[k],n,e);
394 }
395 return res;
396}
397
398/*2
399* substitutes the variable var (from 1..N) by image,
400* does not destroy p and image
401*/
402poly pSubstPoly(poly p, int var, poly image)
403{
404 if (p==NULL) return NULL;
405#ifdef HAVE_PLURAL
407 {
408 return pSubst(pCopy(p),var,image);
409 }
410#endif
411#ifdef HAVE_SHIFTBBA
412 if (rIsLPRing(currRing))
413 {
414 return pSubst(pCopy(p),var,image);
415 }
416#endif
417 return p_SubstPoly(p,var,image,currRing,currRing,ndCopyMap);
418}
419
420/*2
421* substitute the n-th variable by the poly e in id
422* does not destroy id and e
423*/
424ideal idSubstPoly(ideal id, int n, poly e)
425{
426
427#ifdef HAVE_PLURAL
429 {
430 int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
431 ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
432 res->rank = id->rank;
433 for(k--;k>=0;k--)
434 {
435 res->m[k]=pSubst(pCopy(id->m[k]),n,e);
436 }
437 return res;
438 }
439#endif
440#ifdef HAVE_SHIFTBBA
441 if (rIsLPRing(currRing))
442 {
443 int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
444 ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
445 res->rank = id->rank;
446 for(k--;k>=0;k--)
447 {
448 res->m[k]=pSubst(pCopy(id->m[k]),n,e);
449 }
450 return res;
451 }
452#endif
454}
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:4086
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
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:689
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:776
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:604
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition coeffs.h:839
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition numbers.cc:287
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition coeffs.h:713
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:565
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:701
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition coeffs.h:459
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:539
static FORCE_INLINE BOOLEAN nCoeff_is_algExt(const coeffs r)
TRUE iff r represents an algebraic extension field.
Definition coeffs.h:903
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:609
@ n_rep_poly
(poly), see algext.h
Definition coeffs.h:120
@ n_rep_rat_fct
(fraction), see transext.h
Definition coeffs.h:121
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition coeffs.h:80
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition coeffs.h:579
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:472
#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
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:162
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:137
@ END_RING
Definition grammar.cc:311
@ IDEAL_CMD
Definition grammar.cc:285
@ MATRIX_CMD
Definition grammar.cc:287
@ BUCKET_CMD
Definition grammar.cc:284
@ IMAP_CMD
Definition grammar.cc:299
@ MAP_CMD
Definition grammar.cc:286
@ BEGIN_RING
Definition grammar.cc:283
@ MODUL_CMD
Definition grammar.cc:288
@ VECTOR_CMD
Definition grammar.cc:293
@ NUMBER_CMD
Definition grammar.cc:289
@ POLY_CMD
Definition grammar.cc:290
@ FETCH_CMD
Definition grammar.cc:296
#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:402
ideal idSubstPoly(ideal id, int n, poly e)
Definition maps_ip.cc:424
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:385
poly pSubstPar(poly p, int par, poly image)
Definition maps_ip.cc:265
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:387
#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
#define nInit(i)
Definition numbers.h:24
#define omStrDup(s)
#define omAllocBin(bin)
#define omFreeBin(addr, bin)
#define NULL
Definition omList.c:12
#define TEST_V_ALLWARN
Definition options.h:145
poly n_PermNumber(const number z, const int *par_perm, const int, const ring src, const ring dst)
Definition p_polys.cc:4049
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:4152
void p_Normalize(poly p, const ring r)
Definition p_polys.cc:3835
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition p_polys.cc:1474
static BOOLEAN p_IsConstant(const poly p, const ring r)
Definition p_polys.h:1978
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:846
#define p_Test(p, r)
Definition p_polys.h:161
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
#define NUM
Definition readcf.cc:180
void PrintS(const char *s)
Definition reporter.cc:284
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:405
static int rPar(const ring r)
(r->cf->P)
Definition ring.h:604
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:416
poly sBucketPeek(sBucket_pt b)
Definition sbuckets.cc:455
ideal idInit(int idsize, int rank)
initialise an ideal / module
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
#define R
Definition sirandom.c:27
sleftv * leftv
Definition structs.h:57
@ LIST_CMD
Definition tok.h:118