My Project
Loading...
Searching...
No Matches
maps_ip.cc File Reference
#include "kernel/mod2.h"
#include "coeffs/numbers.h"
#include "coeffs/coeffs.h"
#include "polys/monomials/ring.h"
#include "polys/monomials/maps.h"
#include "polys/matpol.h"
#include "polys/prCopy.h"
#include "polys/ext_fields/transext.h"
#include "misc/options.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/maps/gen_maps.h"
#include "maps_ip.h"
#include "ipid.h"
#include "lists.h"
#include "tok.h"
#include "ipshell.h"

Go to the source code of this file.

Macros

#define TRANSEXT_PRIVATES
 

Functions

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

Macro Definition Documentation

◆ TRANSEXT_PRIVATES

#define TRANSEXT_PRIVATES

Definition at line 7 of file maps_ip.cc.

Function Documentation

◆ idSubstPar()

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

Definition at line 386 of file maps_ip.cc.

387{
388 int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
389 ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
390
391 res->rank = id->rank;
392 for(k--;k>=0;k--)
393 {
394 res->m[k]=pSubstPar(id->m[k],n,e);
395 }
396 return res;
397}
int k
Definition cfEzgcd.cc:99
poly * m
Definition matpol.h:18
CanonicalForm res
Definition facAbsFact.cc:60
poly pSubstPar(poly p, int par, poly image)
Definition maps_ip.cc:266
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

◆ idSubstPoly()

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

Definition at line 425 of file maps_ip.cc.

426{
427
428#ifdef HAVE_PLURAL
430 {
431 int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
432 ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
433 res->rank = id->rank;
434 for(k--;k>=0;k--)
435 {
436 res->m[k]=pSubst(pCopy(id->m[k]),n,e);
437 }
438 return res;
439 }
440#endif
441#ifdef HAVE_SHIFTBBA
442 if (rIsLPRing(currRing))
443 {
444 int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
445 ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
446 res->rank = id->rank;
447 for(k--;k>=0;k--)
448 {
449 res->m[k]=pSubst(pCopy(id->m[k]),n,e);
450 }
451 return res;
452 }
453#endif
455}
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition numbers.cc:287
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
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
#define pSubst(p, n, e)
Definition polys.h:366
#define pCopy(p)
return a copy of the poly
Definition polys.h:186
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:406
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.

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 case SMATRIX_CMD:
170 {
171 int C=((matrix)data)->cols();
172 int R;
173 matrix m=NULL;
174 if (w->rtyp==MAP_CMD) R=1;
175 else R=((matrix)data)->rows();
176 char *tmpR=NULL;
177 if(w->rtyp==MAP_CMD)
178 {
179 tmpR=((map)data)->preimage;
180 ((matrix)data)->rank=((matrix)data)->rows();
181 }
182 if (
183 (what==FETCH_CMD) && (preimage_r->cf == currRing->cf)
184#ifdef HAVE_SHIFTBBA
186#endif
187 )
188 {
189 m=mpNew(R,C);
190 for (i=R*C-1;i>=0;i--)
191 {
192 m->m[i]=prCopyR(((ideal)data)->m[i], preimage_r, currRing);
193 pTest(m->m[i]);
194 }
195 }
196 else if ((what==IMAP_CMD) || (what==FETCH_CMD))
197 {
198 m=(matrix)id_PermIdeal((ideal)data,R,C,perm,preimage_r,currRing,
199 nMap,par_perm,P,use_mult);
200 }
201 else /* (what==MAP_CMD) */
202 {
203 assume(what==MAP_CMD);
204 m=mpNew(R,C);
205 matrix s=mpNew(N,maMaxDeg_Ma((ideal)data,preimage_r));
206 for (i=R*C-1;i>=0;i--)
207 {
208 m->m[i]=maEval(theMap, ((ideal)data)->m[i], preimage_r, nMap, (ideal)s, currRing);
209 pTest(m->m[i]);
210 }
211 idDelete((ideal *)&s);
212 }
213 if(w->rtyp==MAP_CMD)
214 {
215 ((map)data)->preimage=tmpR;
216 ((map)m)->preimage=omStrDup(tmpR);
217 }
218 else
219 {
220 m->rank=((matrix)data)->rank;
221 }
222 res->data=(char *)m;
223 idTest((ideal) m);
224 break;
225 }
226
227 case LIST_CMD:
228 {
229 lists l=(lists)data;
231 ml->Init(l->nr+1);
232 for(i=0;i<=l->nr;i++)
233 {
234 if (((l->m[i].rtyp>BEGIN_RING)&&(l->m[i].rtyp<END_RING))
235 ||(l->m[i].rtyp==LIST_CMD))
236 {
237 if (maApplyFetch(what,theMap,&ml->m[i],&l->m[i],
238 preimage_r,perm,par_perm,P,nMap))
239 {
240 ml->Clean();
242 res->rtyp=0;
243 return TRUE;
244 }
245 }
246 else
247 {
248 ml->m[i].Copy(&l->m[i]);
249 }
250 }
251 res->data=(char *)ml;
252 break;
253 }
254 default:
255 {
256 return TRUE;
257 }
258 }
259 return FALSE;
260}
int BOOLEAN
Definition auxiliary.h:88
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
void * ADDRESS
Definition auxiliary.h:120
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
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
void Copy(leftv e)
Definition subexpr.cc:689
sleftv * m
Definition lists.h:46
void Clean(ring r=currRing)
Definition lists.h:26
INLINE_THIS void Init(int l=0)
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition coeffs.h:839
#define n_Test(a, r)
BOOLEAN n_Test(number a, const coeffs r)
Definition coeffs.h:713
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 void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition coeffs.h:579
#define Print
Definition emacs.cc:80
#define Warn
Definition emacs.cc:77
const CanonicalForm int s
Definition facAbsFact.cc:51
const CanonicalForm & w
Definition facAbsFact.cc:51
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:164
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
@ SMATRIX_CMD
Definition grammar.cc:292
@ 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
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
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
#define assume(x)
Definition mod2.h:389
slists * lists
#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:4108
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:4211
#define p_Test(p, r)
Definition p_polys.h:161
#define pTest(p)
Definition polys.h:415
poly prCopyR(poly p, ring src_r, ring dest_r)
Definition prCopy.cc:34
void PrintS(const char *s)
Definition reporter.cc:284
poly sBucketPeek(sBucket_pt b)
Definition sbuckets.cc:455
sBucket * sBucket_pt
Definition sbuckets.h:16
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
@ LIST_CMD
Definition tok.h:118

◆ pSubstPar()

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

Definition at line 266 of file maps_ip.cc.

267{
268 const ring R = currRing->cf->extRing;
269 ideal theMapI = idInit(rPar(currRing),1);
270 nMapFunc nMap = n_SetMap(R->cf, currRing->cf);
271 int i;
272 for(i = rPar(currRing);i>0;i--)
273 {
274 if (i != par)
275 theMapI->m[i-1]= p_NSet(n_Param(i, currRing), currRing);
276 else
277 theMapI->m[i-1] = p_Copy(image, currRing);
278 p_Test(theMapI->m[i-1],currRing);
279 }
280 //iiWriteMatrix((matrix)theMapI,"map:",1,currRing,0);
281
282 map theMap=(map)theMapI;
283 theMap->preimage=NULL;
284
286 sleftv tmpW;
287 poly res=NULL;
288
290 if (currRing->cf->rep==n_rep_rat_fct )
291 {
292 while (p!=NULL)
293 {
294 memset(v,0,sizeof(sleftv));
295
296 number d = n_GetDenom(pGetCoeff(p), currRing->cf);
297 p_Test((poly)NUM((fraction)d), R);
298
299 if ( n_IsOne (d, currRing->cf) )
300 {
301 n_Delete(&d, currRing->cf); d = NULL;
302 }
303 else if (!p_IsConstant((poly)NUM((fraction)d), R))
304 {
305 WarnS("ignoring denominators of coefficients...");
306 n_Delete(&d, currRing->cf); d = NULL;
307 }
308
309 number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
310 memset(&tmpW,0,sizeof(sleftv));
311 tmpW.rtyp = POLY_CMD;
312 p_Test((poly)NUM((fraction)num), R);
313
314 tmpW.data = NUM ((fraction)num); // a copy of this poly will be used
315
316 p_Normalize(NUM((fraction)num),R);
317 if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
318 {
319 WerrorS("map failed");
320 v->data=NULL;
321 }
322 n_Delete(&num, currRing->cf);
323 //TODO check for memory leaks
324 poly pp = pHead(p);
325 //PrintS("map:");pWrite(pp);
326 if( d != NULL )
327 {
328 pSetCoeff(pp, n_Invers(d, currRing->cf));
329 n_Delete(&d, currRing->cf); // d = NULL;
330 }
331 else
332 pSetCoeff(pp, nInit(1));
333
334 //PrintS("->");pWrite((poly)(v->data));
335 poly ppp = pMult((poly)(v->data),pp);
336 //PrintS("->");pWrite(ppp);
337 res=pAdd(res,ppp);
338 pIter(p);
339 }
340 }
341 else if (currRing->cf->rep==n_rep_poly )
342 {
343 while (p!=NULL)
344 {
345 memset(v,0,sizeof(sleftv));
346
347 number num = n_GetNumerator(pGetCoeff(p), currRing->cf);
348 memset(&tmpW,0,sizeof(sleftv));
349 tmpW.rtyp = POLY_CMD;
350 p_Test((poly)num, R);
351
352
353 p_Normalize((poly)num,R);
354 if (num==NULL) num=(number)R->qideal->m[0];
355 tmpW.data = num; // a copy of this poly will be used
356 if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,R,NULL,NULL,0,nMap))
357 {
358 WerrorS("map failed");
359 v->data=NULL;
360 }
361 if (num!=(number)R->qideal->m[0]) n_Delete(&num, currRing->cf);
362 //TODO check for memory leaks
363 poly pp = pHead(p);
364 //PrintS("map:");pWrite(pp);
365 pSetCoeff(pp,n_Init(1,currRing->cf));
366 //PrintS("cf->");pWrite((poly)(v->data));
367 poly ppp = pMult((poly)(v->data),pp);
368 //PrintS("->");pWrite(ppp);
369 res=pAdd(res,ppp);
370 pIter(p);
371 }
372 }
373 else
374 {
375 WerrorS("cannot apply subst for these coefficients");
376 }
377 idDelete((ideal *)(&theMap));
379 return res;
380}
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition cf_gcd.cc:676
CanonicalForm num(const CanonicalForm &f)
int p
Definition cfModGcd.cc:4086
Class used for (list of) interpreter objects.
Definition subexpr.h:83
int rtyp
Definition subexpr.h:91
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....
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 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 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 BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:472
#define WarnS
Definition emacs.cc:78
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
void WerrorS(const char *s)
Definition feFopen.cc:24
EXTERN_VAR omBin sleftv_bin
Definition ipid.h:145
#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
#define nInit(i)
Definition numbers.h:24
void p_Normalize(poly p, const ring r)
Definition p_polys.cc:3894
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:1980
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition p_polys.h:848
#define pAdd(p, q)
Definition polys.h:204
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition polys.h:68
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition polys.h:32
#define pMult(p, q)
Definition polys.h:208
#define NUM
Definition readcf.cc:180
static int rPar(const ring r)
(r->cf->P)
Definition ring.h:605
ideal idInit(int idsize, int rank)
initialise an ideal / module
sleftv * leftv
Definition structs.h:53

◆ pSubstPoly()

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

Definition at line 403 of file maps_ip.cc.

404{
405 if (p==NULL) return NULL;
406#ifdef HAVE_PLURAL
408 {
409 return pSubst(pCopy(p),var,image);
410 }
411#endif
412#ifdef HAVE_SHIFTBBA
413 if (rIsLPRing(currRing))
414 {
415 return pSubst(pCopy(p),var,image);
416 }
417#endif
418 return p_SubstPoly(p,var,image,currRing,currRing,ndCopyMap);
419}
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