My Project
Loading...
Searching...
No Matches
gen_maps.cc File Reference

Go to the source code of this file.

Functions

static void find_subst_for_map (const ring preimage_r, const ring image_r, const ideal image, int &var, poly &p)
 
ideal maMapIdeal (const ideal map_id, const ring preimage_r, const ideal image_id, const ring image_r, const nMapFunc nMap)
 polynomial map for ideals/module/matrix map_id: the ideal to map map_r: the base ring for map_id image_id: the image of the variables image_r: the base ring for image_id nMap: map for coefficients
 
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_id: the image of the variables image_r: the base ring for image_id nMap: map for coefficients
 
number maEvalAt (const poly p, const number *pt, const ring r)
 evaluate the polynomial p at the pt given by the array pt
 

Function Documentation

◆ find_subst_for_map()

static void find_subst_for_map ( const ring preimage_r,
const ring image_r,
const ideal image,
int & var,
poly & p )
static

Definition at line 16 of file gen_maps.cc.

17{
18 p=NULL;
19 var=0;
20 int i,v;
21 for (i=si_min(IDELEMS(image),preimage_r->N)-1; i>=0; i--)
22 {
23 if (image->m[i]!=NULL)
24 {
25 if ((pNext(image->m[i])==NULL)
26 && (n_IsOne(pGetCoeff(image->m[i]),image_r->cf)))
27 {
28 v=p_IsUnivariate(image->m[i],image_r);
29 if ((v<=0) /*not univariate */
30 || (v!=i+1) /* non-trivial */
31 || (p_GetExp(image->m[i],v,image_r)!=1))
32 {
33 if (var==0)
34 {
35 var=i+1;
36 p=image->m[i];
37 }
38 else /* found second non-trivial entry */
39 {
40 goto non_trivial;
41 }
42 }
43 }
44 else
45 {
46 if (var==0)
47 {
48 var=i+1;
49 p=image->m[i];
50 }
51 else /* found second non-trivial entry */
52 {
53 goto non_trivial;
54 }
55 }
56 }
57 else
58 {
59 if (var==0)
60 {
61 var=i+1;
62 p=image->m[i];
63 }
64 else /* found second non-trivial entry */
65 {
66 goto non_trivial;
67 }
68 }
69 }
70 return;
71 //Print("elms:%d, N:%d\n",IDELEMS(image),preimage_r->N);
72 //iiWriteMatrix((matrix)image,"_",1,image_r,0);
73 //PrintS("\npreimage:\n");rWrite(preimage_r);
74 //PrintS("image:\n");rWrite(image_r);
75 //Print("\nsusbt: v%d -> ",var);
76 //p_wrp(p,image_r,image_r);
77non_trivial:
78 var=0;
79 p=NULL;
80}
static int si_min(const int a, const int b)
Definition auxiliary.h:126
int i
Definition cfEzgcd.cc:132
int p
Definition cfModGcd.cc:4086
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition coeffs.h:472
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
#define pNext(p)
Definition monomials.h:36
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 NULL
Definition omList.c:12
int p_IsUnivariate(poly p, const ring r)
return i, if poly depends only on var(i)
Definition p_polys.cc:1248
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition p_polys.h:471
#define IDELEMS(i)

◆ maEvalAt()

number maEvalAt ( const poly p,
const number * pt,
const ring r )

evaluate the polynomial p at the pt given by the array pt

Definition at line 172 of file gen_maps.cc.

173{
174 ideal map=idInit(r->N,1);
175 for(int i=r->N-1;i>=0;i--)
176 {
177 map->m[i]=p_NSet(n_Copy(pt[i],r->cf),r);
178 }
179 poly v=maMapPoly(p,r,map,r,ndCopyMap);
180 id_Delete(&map,r);
181 number vv;
182 if (v==NULL)
183 vv=n_Init(0,r->cf);
184 else
185 {
186 vv=pGetCoeff(v);
187 p_LmFree(&v,r);
188 }
189 return vv;
190}
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition coeffs.h:455
number ndCopyMap(number a, const coeffs src, const coeffs dst)
Definition numbers.cc:287
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
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
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
Definition p_polys.cc:1474
static void p_LmFree(poly p, ring)
Definition p_polys.h:685
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix

◆ maMapIdeal()

ideal maMapIdeal ( const ideal map_id,
const ring preimage_r,
const ideal image_id,
const ring image_r,
const nMapFunc nMap )

polynomial map for ideals/module/matrix map_id: the ideal to map map_r: the base ring for map_id image_id: the image of the variables image_r: the base ring for image_id nMap: map for coefficients

Definition at line 88 of file gen_maps.cc.

89{
90 // handle special cases
91 if (IDELEMS(map_id)<=0)
92 return idInit(0,map_id->rank);
93 if(!rIsNCRing(image_r))
94 {
95 // heuristic:
96 // is the map a permutation ?
97 matrix m=ma_ApplyPermForMap((matrix)map_id,preimage_r,image_id,image_r,nMap);
98 if (m!=NULL)
99 {
100 if (TEST_OPT_PROT) PrintS("map is a permutation\n");
101 return (ideal)m;
102 }
103 // ----------------------------------------------------------
104 // is it a substitution of one variable ?
105 {
106 poly p;
107 int var;
108 find_subst_for_map(preimage_r,image_r,image_id,var,p);
109 if (var!=0)
110 {
111 if (TEST_OPT_PROT) PrintS("map is a substitution\n");
112 return id_SubstPoly(map_id,var,p,preimage_r,image_r,nMap);
113 }
114 }
115 // ----------------------------------------------------------
116 // long polys in the image ?: possibility of many common subexpressions
117 if ((nMap==ndCopyMap) /* and !rIsPluralRing(image_r) */
118 && (map_id->nrows==1) /* i.e. only for ideal/map */
119 && (map_id->rank==1))
120 {
121 int sz=IDELEMS(map_id);
122 int sz_l=0;
123 int sz_more=0;
124 int t,i;
125 for(i=sz-1;i>=0;i--)
126 {
127 sz_l+=pLength(map_id->m[i]);
128 }
129 for(i=IDELEMS(image_id)-1;i>=0;i--)
130 {
131 t=pLength(image_id->m[i]);
132 if ((t==0) || (t>1)) sz_more++;
133 }
134 if (((sz_l > sz*2) && (sz_more != 1))||(sz<5))
135 {
136 if (TEST_OPT_PROT) PrintS("map via common subexpressions\n");
137 return fast_map_common_subexp(map_id, preimage_r, image_id, image_r);
138 }
139 }
140 }
141 // ----------------------------------------------------------
142 // otherwise: try the generic method (generic map with cache)
143 if (TEST_OPT_PROT) PrintS("map with cache\n");
144 int C=((matrix)map_id)->cols();
145 int R=((matrix)map_id)->rows();
146 matrix m=mpNew(R,C);
147 int N = preimage_r->N;
148 matrix cache=mpNew(N,maMaxDeg_Ma(map_id,preimage_r));
149 int i;
150 for (i=R*C-1;i>=0;i--)
151 {
152 if (map_id->m[i]!=NULL)
153 {
154 m->m[i]=maEval((map)image_id, map_id->m[i], preimage_r, nMap, (ideal)cache, image_r);
155 p_Test(m->m[i],image_r);
156 }
157 }
158 idDelete((ideal *)&cache);
159 ideal ii=(ideal)m;
160 ii->rank=((ideal)map_id)->rank;
161 return (ideal)m;
162}
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
int m
Definition cfEzgcd.cc:128
ideal fast_map_common_subexp(const ideal map_id, const ring map_r, const ideal image_id, const ring image_r)
Definition fast_maps.cc:354
matrix ma_ApplyPermForMap(const matrix to_map, const ring preimage_r, const ideal image, const ring image_r, const nMapFunc nMap)
helper function for maMapIdeal mapping ideal/matrix/module for the case of a permutation: maps the id...
Definition find_perm.cc:69
static void find_subst_for_map(const ring preimage_r, const ring image_r, const ideal image, int &var, poly &p)
Definition gen_maps.cc:16
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
#define idDelete(H)
delete an ideal
Definition ideals.h:29
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
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 TEST_OPT_PROT
Definition options.h:105
static int pLength(poly a)
Definition p_polys.h:190
#define p_Test(p, r)
Definition p_polys.h:161
void PrintS(const char *s)
Definition reporter.cc:284
static BOOLEAN rIsNCRing(const ring r)
Definition ring.h:427
#define R
Definition sirandom.c:27

◆ 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_id: the image of the variables image_r: the base ring for image_id nMap: map for coefficients

Definition at line 164 of file gen_maps.cc.

165{
166 matrix s=mpNew(map_r->N,maMaxDeg_P(map_p, map_r));
167 poly p=maEval((map)image_id, map_p, map_r, nMap, (ideal)s, image_r);
168 id_Delete((ideal*)&s,image_r);
169 return p;
170}
const CanonicalForm int s
Definition facAbsFact.cc:51
int maMaxDeg_P(poly p, ring preimage_r)
Definition maps.cc:398