My Project
Loading...
Searching...
No Matches
Functions | Variables
weight.cc File Reference
#include "misc/auxiliary.h"
#include "misc/options.h"
#include "misc/intvec.h"
#include "polys/monomials/ring.h"
#include "polys/monomials/p_polys.h"
#include "polys/weight.h"

Go to the source code of this file.

Functions

double wFunctionalMora (int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
 
double wFunctionalBuch (int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
 
void wAdd (int *A, int mons, int kn, int xx, int rvar)
 
void wNorm (int *degw, int *lpol, int npol, double *rel)
 
void wFirstSearch (int *A, int *x, int mons, int *lpol, int npol, double *rel, double *fopt, double wNsqr, int rvar)
 
void wSecondSearch (int *A, int *x, int *lpol, int npol, int mons, double *rel, double *fk, double wNsqr, int rvar)
 
void wGcd (int *x, int n)
 
static void wDimensions (poly *s, int sl, int *lpol, int *npol, int *mons)
 
static void wInit (poly *s, int sl, int mons, int *A, const ring R)
 
void wCall (poly *s, int sl, int *x, double wNsqr, const ring R)
 
void kEcartWeights (poly *s, int sl, short *eweight, const ring R)
 
int * iv2array (intvec *iv, const ring R)
 
long totaldegreeWecart (poly p, ring r)
 
long totaldegreeWecart_IV (poly p, ring r, const int *w)
 
long maxdegreeWecart (poly p, int *l, ring r)
 

Variables

THREAD_VAR double(* wFunctional )(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
 

Function Documentation

◆ iv2array()

int * iv2array ( intvec iv,
const ring  R 
)

Definition at line 200 of file weight.cc.

201{
202 int *s=(int *)omAlloc0((rVar(R)+1)*sizeof(int));
203 int len=0;
204 if(iv!=NULL)
205 len=si_min(iv->length(),rVar(R)); // usually: rVar(R)==length()
206 int i;
207 //for(i=pVariables;i>len;i--) s[i]=1;
208 for(i=len;i>0;i--) s[i]=(*iv)[i-1];
209 return s;
210}
static int si_min(const int a, const int b)
Definition: auxiliary.h:125
int i
Definition: cfEzgcd.cc:132
int length() const
Definition: intvec.h:94
const CanonicalForm int s
Definition: facAbsFact.cc:51
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#define NULL
Definition: omList.c:12
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:592
#define R
Definition: sirandom.c:27

◆ kEcartWeights()

void kEcartWeights ( poly *  s,
int  sl,
short *  eweight,
const ring  R 
)

Definition at line 182 of file weight.cc.

183{
184 int n, i;
185 int *x;
186
187 *eweight = 0;
188 n = rVar(R);
191 else
193 x = (int * )omAlloc(2 * (n + 1) * sizeof(int));
194 wCall(s, sl, x, (double)2.0 / (double)n, R);
195 for (i = n; i!=0; i--)
196 eweight[i] = x[i + n + 1];
197 omFreeSize((ADDRESS)x, 2 * (n + 1) * sizeof(int));
198}
void * ADDRESS
Definition: auxiliary.h:119
Variable x
Definition: cfModGcd.cc:4082
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc(size)
Definition: omAllocDecl.h:210
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:760
THREAD_VAR double(* wFunctional)(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
Definition: weight.cc:20
void wCall(poly *s, int sl, int *x, double wNsqr, const ring R)
Definition: weight.cc:108
double wFunctionalBuch(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
Definition: weight0.cc:78
double wFunctionalMora(int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr)
Definition: weight0.cc:34

◆ maxdegreeWecart()

long maxdegreeWecart ( poly  p,
int *  l,
ring  r 
)

Definition at line 247 of file weight.cc.

248{
249 short k=p_GetComp(p, r);
250 int ll=1;
251 long t,max;
252
254 pIter(p);
255 while ((p!=NULL) && (p_GetComp(p, r)==k))
256 {
257 t=totaldegreeWecart(p, r);
258 if (t>max) max=t;
259 ll++;
260 pIter(p);
261 }
262 *l=ll;
263 return max;
264}
int l
Definition: cfEzgcd.cc:100
int k
Definition: cfEzgcd.cc:99
int p
Definition: cfModGcd.cc:4078
static int max(int a, int b)
Definition: fast_mult.cc:264
#define p_GetComp(p, r)
Definition: monomials.h:64
#define pIter(p)
Definition: monomials.h:37
long totaldegreeWecart(poly p, ring r)
Definition: weight.cc:217

◆ totaldegreeWecart()

long totaldegreeWecart ( poly  p,
ring  r 
)

Definition at line 217 of file weight.cc.

218{
219 int i;
220 long j =0;
221
222 for (i=rVar(r); i>0; i--)
223 j += (int)(p_GetExp(p,i,r) * ecartWeights[i]);
224 return j;
225}
int j
Definition: facHensel.cc:110
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:467
EXTERN_VAR short * ecartWeights
Definition: weight.h:12

◆ totaldegreeWecart_IV()

long totaldegreeWecart_IV ( poly  p,
ring  r,
const int *  w 
)

Definition at line 231 of file weight.cc.

232{
233 int i;
234 long j =0;
235
236 for (i=rVar(r); i>0; i--)
237 j += (long)((int)(p_GetExp(p,i,r) * w[i]));
238 return j;
239}
const CanonicalForm & w
Definition: facAbsFact.cc:51

◆ wAdd()

void wAdd ( int *  A,
int  mons,
int  kn,
int  xx,
int  rvar 
)

Definition at line 132 of file weight0.cc.

133{
134 int i, *B, *ex;
135
136 B = A + ((kn - 1) * mons);
137 ex = A + (rvar * mons);
138 i = mons;
139 if (xx == 1)
140 {
141 for (/* i=mons */; i!=0 ; i--)
142 *ex++ += *B++;
143 }
144 else
145 {
146 for (/* i=mons */; i!=0 ; i--)
147 *ex++ += (*B++) * xx;
148 }
149}
b *CanonicalForm B
Definition: facBivar.cc:52
#define A
Definition: sirandom.c:24

◆ wCall()

void wCall ( poly *  s,
int  sl,
int *  x,
double  wNsqr,
const ring  R 
)

Definition at line 108 of file weight.cc.

109{
110 int n, q, npol, mons, i;
111 int *A, *xopt, *lpol, *degw;
112 double f1, fx, eps, *rel;
113 void *adr;
114
115 n = rVar(R);
116 lpol = (int * )omAlloc((sl + 1) * sizeof(int));
117 wDimensions(s, sl, lpol, &npol, &mons);
118 xopt = x + (n + 1);
119 for (i = n; i!=0; i--)
120 xopt[i] = 1;
121 if (mons==0)
122 {
123 omFreeSize((ADDRESS)lpol, (sl + 1) * sizeof(int));
124 return;
125 }
126 adr = (void * )omAllocAligned(npol * sizeof(double));
127 rel = (double*)adr;
128 q = (n + 1) * mons * sizeof(int);
129 A = (int * )omAlloc(q);
130 wInit(s, sl, mons, A, R);
131 degw = A + (n * mons);
132 memset(degw, 0, mons * sizeof(int));
133 for (i = n; i!=0; i--)
134 wAdd(A, mons, i, 1, rVar(R));
135 wNorm(degw, lpol, npol, rel);
136 f1 = (*wFunctional)(degw, lpol, npol, rel, (double)1.0, wNsqr);
137 if (TEST_OPT_PROT) Print("// %e\n",f1);
138 eps = f1;
139 fx = (double)2.0 * eps;
140 memset(x, 0, (n + 1) * sizeof(int));
141 wFirstSearch(A, x, mons, lpol, npol, rel, &fx, wNsqr, rVar(R));
142 if (TEST_OPT_PROT) Print("// %e\n",fx);
143 memcpy(x + 1, xopt + 1, n * sizeof(int));
144 memset(degw, 0, mons * sizeof(int));
145 for (i = n; i!=0; i--)
146 {
147 x[i] *= 16;
148 wAdd(A, mons, i, x[i], rVar(R));
149 }
150 wSecondSearch(A, x, lpol, npol, mons, rel, &fx, wNsqr, rVar(R));
151 if (TEST_OPT_PROT) Print("// %e\n",fx);
152 if (fx >= eps)
153 {
154 for (i = n; i!=0; i--)
155 xopt[i] = 1;
156 }
157 else
158 {
159 wGcd(xopt, n);
160// if (BTEST1(22))
161// {
162// f1 = fx + (double)0.1 * (f1 - fx);
163// wSimple(x, n);
164// memset(degw, 0, mons * sizeof(int));
165// for (i = n; i!=0; i--)
166// wAdd(A, mons, i, x[i], rVar(R));
167// eps = wPrWeight(x, n);
168// fx = (*wFunctional)(degw, lpol, npol, rel, eps);
169// if (fx < f1)
170// {
171// if (TEST_OPT_PROT) Print("// %e\n",fx);
172// memcpy(xopt + 1, x + 1, n * sizeof(int));
173// }
174// }
175 }
176 omFreeSize((ADDRESS)A, q);
177 omFreeSize((ADDRESS)lpol, (sl + 1) * sizeof(int));
178 omFreeSize((ADDRESS)adr, npol * sizeof(double));
179}
#define Print
Definition: emacs.cc:80
#define omAllocAligned
Definition: omAllocDecl.h:273
#define TEST_OPT_PROT
Definition: options.h:104
void wFirstSearch(int *A, int *x, int mons, int *lpol, int npol, double *rel, double *fopt, double wNsqr, int rvar)
Definition: weight0.cc:152
void wSecondSearch(int *A, int *x, int *lpol, int npol, int mons, double *rel, double *fk, double wNsqr, int rvar)
Definition: weight0.cc:295
static void wDimensions(poly *s, int sl, int *lpol, int *npol, int *mons)
Definition: weight.cc:34
void wNorm(int *degw, int *lpol, int npol, double *rel)
Definition: weight0.cc:463
void wGcd(int *x, int n)
Definition: weight0.cc:352
static void wInit(poly *s, int sl, int mons, int *A, const ring R)
Definition: weight.cc:64
void wAdd(int *A, int mons, int kn, int xx, int rvar)
Definition: weight0.cc:132

◆ wDimensions()

static void wDimensions ( poly *  s,
int  sl,
int *  lpol,
int *  npol,
int *  mons 
)
static

Definition at line 34 of file weight.cc.

35{
36 int i, i1, j, k;
37 poly p, q;
38
39 i1 = j = 0;
40 for (i = 0; i <= sl; i++)
41 {
42 p = s[i];
43 if (p!=NULL)
44 {
45 k = 1;
46 q = pNext(p);
47 while (q!=NULL)
48 {
49 k++;
50 q = pNext(q);
51 }
52 if (k > 1)
53 {
54 lpol[i1++] = k;
55 j += k;
56 }
57 }
58 }
59 *npol = i1;
60 *mons = j;
61}
#define pNext(p)
Definition: monomials.h:36

◆ wFirstSearch()

void wFirstSearch ( int *  A,
int *  x,
int  mons,
int *  lpol,
int  npol,
double *  rel,
double *  fopt,
double  wNsqr,
int  rvar 
)

Definition at line 152 of file weight0.cc.

154{
155 int a0, a, n, xn, t, xx, y1;
156 int *y, *degw, *xopt;
157 double fy, fmax, wx;
158 double *pr;
159 void *adr;
160
161 fy = *fopt;
162 n = rvar;
163 xn = n + 6 + (21 / n);
164 a0 = n * sizeof(double);
165 a = n * sizeof(int);
166 y = (int * )omAlloc((long)a);
167 adr = (void * )omAllocAligned((long)a0);
168 pr = (double*)adr;
169 *pr = (double)1.0;
170 *y = 0;
171 degw = A + (n * mons);
172 xopt = x + (n + 2);
173 t = 1;
174 loop
175 {
176 while (t < n)
177 {
178 xx = x[t] + 1;
179 wx = pr[t-1] * (double)xx;
180 y1 = y[t-1] + xx;
181 if ((y1 + n - t) <= xn)
182 {
183 pr[t] = wx;
184 y[t] = y1;
185 x[t] = xx;
186 if (xx > 1)
187 wAdd(A, mons, t, 1, rvar);
188 t++;
189 }
190 else
191 {
192 xx = x[t] - 1;
193 x[t] = 0;
194 if (xx!=0)
195 wSub(A, mons, t, xx, rvar);
196 t--;
197 if (t==0)
198 {
199 *fopt = fy;
200 omFreeSize((ADDRESS)y, (long)a);
201 omFreeSize((ADDRESS)adr, (long)a0);
202 return;
203 }
204 }
205 }
206 xx = xn - y[t-1];
207 wx = pr[t-1] * (double)xx;
208 x[t] = xx;
209 xx--;
210 if (xx!=0)
211 wAdd(A, mons, t, xx, rvar);
212 fmax = (*wFunctional)(degw, lpol, npol, rel, wx,wNsqr);
213 if (xx!=0)
214 wSub(A, mons, t, xx, rvar);
215 if (fmax < fy)
216 {
217 fy = fmax;
218 memcpy(xopt, x + 1, a);
219 }
220 t--;
221 } /* end loop */
222}
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:53
#define loop
Definition: structs.h:75
VAR int xn
Definition: walk.cc:4508
static void wSub(int *A, int mons, int kn, int xx, int rvar)
Definition: weight0.cc:112
void wAdd(int *A, int mons, int kn, int xx, int rvar)
Definition: weight0.cc:132

◆ wFunctionalBuch()

double wFunctionalBuch ( int *  degw,
int *  lpol,
int  npol,
double *  rel,
double  wx,
double  wNsqr 
)

Definition at line 78 of file weight0.cc.

80{
81 int i, j, ecl, ecu, ec;
82 int *ex;
83 double gfmax, ghom, pfmax;
84 double *r;
85
86 ex = degw;
87 r = rel;
88 gfmax = (double)0.0;
89 ghom = (double)1.0;
90 for (i = 0; i < npol; i++)
91 {
92 ecu = ecl = *ex++;
93 for (j = lpol[i] - 1; j!=0 ; j--)
94 {
95 ec = *ex++;
96 if (ec < ecl)
97 ecl = ec;
98 else if (ec > ecu)
99 ecu = ec;
100 }
101 pfmax = (double)ecl / (double)ecu;
102 if (pfmax < ghom)
103 ghom = pfmax;
104 gfmax += (double)(ecu * ecu) * (*r++);
105 }
106 if (ghom > (double)0.5)
107 gfmax *= ((double)1.0 - (ghom * ghom)) / (double)0.75;
108 return gfmax / pow(wx, wNsqr);
109}
Rational pow(const Rational &a, int e)
Definition: GMPrat.cc:411

◆ wFunctionalMora()

double wFunctionalMora ( int *  degw,
int *  lpol,
int  npol,
double *  rel,
double  wx,
double  wNsqr 
)

Definition at line 34 of file weight0.cc.

36{
37 int i, j, e1, ecu, ecl, ec;
38 int *ex;
39 double gfmax, gecart, ghom, pfmax;
40 double *r;
41
42 ex = degw;
43 r = rel;
44 gfmax = (double)0.0;
45 gecart = (double)0.4 + (double)npol;
46 ghom = (double)1.0;
47 for (i = 0; i < npol; i++)
48 {
49 ecl = ecu = e1 = *ex++;
50 for (j = lpol[i] - 1; j!=0; j--)
51 {
52 ec = *ex++;
53 if (ec > ecu)
54 ecu = ec;
55 else if (ec < ecl)
56 ecl = ec;
57 }
58 pfmax = (double)ecl / (double)ecu;
59 if (pfmax < ghom)
60 ghom = pfmax;
61 pfmax = (double)e1 / (double)ecu;
62 if (pfmax > (double)0.5)
63 gecart -= (pfmax * pfmax);
64 else
65 gecart -= (double)0.25;
66 ecu = 2 * ecu - ecl;
67 gfmax += (double)(ecu * ecu) * (*r++);
68 }
69 if (ghom > (double)0.8)
70 {
71 ghom *= (double)5.0;
72 gecart *= ((double)5.0 - ghom);
73 }
74 return (gfmax * gecart) / pow(wx, wNsqr);
75}

◆ wGcd()

void wGcd ( int *  x,
int  n 
)

Definition at line 352 of file weight0.cc.

353{
354 int i, b, a, h;
355
356 i = n;
357 b = x[i];
358 loop
359 {
360 i--;
361 if (i==0)
362 break;
363 a = x[i];
364 if (a < b)
365 {
366 h = a;
367 a = b;
368 b = h;
369 }
370 do
371 {
372 h = a % b;
373 a = b;
374 b = h;
375 }
376 while (b!=0);
377 b = a;
378 if (b == 1)
379 return;
380 }
381 for (i = n; i!=0 ; i--)
382 x[i] /= b;
383}
CanonicalForm b
Definition: cfModGcd.cc:4103
STATIC_VAR Poly * h
Definition: janet.cc:971

◆ wInit()

static void wInit ( poly *  s,
int  sl,
int  mons,
int *  A,
const ring  R 
)
static

Definition at line 64 of file weight.cc.

65{
66 int n, a, i, j, *B, *C;
67 poly p, q;
68 int *pl;
69
70 B = A;
71 n = rVar(R);
72 a = (n + 1) * sizeof(int);
73 pl = (int *)omAlloc(a);
74 for (i = 0; i <= sl; i++)
75 {
76 p = s[i];
77 if (p!=NULL)
78 {
79 q = pNext(p);
80 if (q!=NULL)
81 {
82 C = B;
83 B++;
84 p_GetExpV(p, pl,R);
85 for (j = 0; j < n; j++)
86 {
87 *C = pl[j+1];
88 C += mons;
89 }
90 }
91 while (q!=NULL)
92 {
93 C = B;
94 B++;
95 p_GetExpV(q, pl,R);
96 for (j = 0; j < n; j++)
97 {
98 *C = pl[j+1];
99 C += mons;
100 }
101 pIter(q);
102 }
103 }
104 }
105 omFreeSize((ADDRESS)pl, a);
106}
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1518

◆ wNorm()

void wNorm ( int *  degw,
int *  lpol,
int  npol,
double *  rel 
)

Definition at line 463 of file weight0.cc.

464{
465 int i, j, ecu, ec;
466 int *ex;
467 double *r;
468
469 ex = degw;
470 r = rel;
471 for (i = 0; i < npol; i++)
472 {
473 ecu = *ex++;
474 for (j = lpol[i] - 1; j!=0 ; j--)
475 {
476 ec = *ex++;
477 if (ec > ecu)
478 ecu = ec;
479 }
480 *r = (double)1.0 / (double)(ecu * ecu);
481 r++;
482 }
483}

◆ wSecondSearch()

void wSecondSearch ( int *  A,
int *  x,
int *  lpol,
int  npol,
int  mons,
double *  rel,
double *  fk,
double  wNsqr,
int  rvar 
)

Definition at line 295 of file weight0.cc.

297{
298 int n, s0, s1, s2, *xopt;
299 double fx, fopt, wx;
300
301 n = rvar;
302 xopt = x + (n + 2);
303 fopt = *fk * (double)0.999999999999;
304 wx = wPrWeight(x, n);
305 loop
306 {
307 wEstimate(A, x, lpol, npol, mons, wx, rel, &fx, &s0, &s1, &s2, wNsqr, rvar);
308 if (fx > fopt)
309 {
310 if (s0!=0)
311 x[s0]--;
312 else if (s1!=0)
313 {
314 x[s1]--;
315 x[s2]--;
316 }
317 else
318 break;
319 }
320 else
321 {
322 fopt = fx;
323 if (s0!=0)
324 {
325 x[s0]--;
326 memcpy(xopt, x + 1, n * sizeof(int));
327 if (s1==0)
328 break;
329 }
330 else if (s1!=0)
331 {
332 x[s1]--;
333 x[s2]--;
334 memcpy(xopt, x + 1, n * sizeof(int));
335 }
336 else
337 break;
338 }
339 if (s0!=0)
340 wSub(A, mons, s0, 1, rvar);
341 else
342 {
343 wSub(A, mons, s1, 1, rvar);
344 wSub(A, mons, s2, 1, rvar);
345 }
346 wx = wPrWeight(x, n);
347 }
348 *fk = fopt;
349}
static void wEstimate(int *A, int *x, int *lpol, int npol, int mons, double wx, double *rel, double *fopt, int *s0, int *s1, int *s2, double wNsqr, int rvar)
Definition: weight0.cc:237
static double wPrWeight(int *x, int n)
Definition: weight0.cc:225

Variable Documentation

◆ wFunctional

THREAD_VAR double(* wFunctional) (int *degw, int *lpol, int npol, double *rel, double wx, double wNsqr) ( int *  degw,
int *  lpol,
int  npol,
double *  rel,
double  wx,
double  wNsqr 
)

Definition at line 20 of file weight.cc.