void BenchGaussjPrec(INT N,INT M)
{
GaussjPrec GP(N,M);
for (INT y=0; y<N ; y++)
{
for (INT x=0; x<N ; x++)
GP.M()(x,y) = NRrandom3()-0.5 + 2 * N * (x==y);
{
for (INT x=0; x<M ; x++)
GP.b()(x,y) = NRrandom3();
}
}
bool OK = GP.init_rec();
BENCH_ASSERT(OK);
{
for (INT y=0; y<N ; y++)
for (INT x=0; x<N ; x++)
GP.M()(x,y) += (NRrandom3()-0.5) * N * 5e-2;
}
for (INT k=0 ; k<10 ; k++)
{
GP.amelior_sol();
}
BENCH_ASSERT(GP.ecart()<epsilon);
}
bench_tensor *tensor_compress(const bench_tensor *sz)
{
int i, rnk;
bench_tensor *x;
BENCH_ASSERT(BENCH_FINITE_RNK(sz->rnk));
for (i = rnk = 0; i < sz->rnk; ++i) {
BENCH_ASSERT(sz->dims[i].n > 0);
if (sz->dims[i].n != 1)
++rnk;
}
x = mktensor(rnk);
for (i = rnk = 0; i < sz->rnk; ++i) {
if (sz->dims[i].n != 1)
x->dims[rnk++] = sz->dims[i];
}
if (rnk) {
/* God knows how qsort() behaves if n==0 */
qsort(x->dims, (size_t)x->rnk, sizeof(bench_iodim),
(int (*)(const void *, const void *))dimcmp);
}
return x;
}
void bench_filo()
{
All_Memo_counter MC_INIT;
stow_memory_counter(MC_INIT);
INT nb = 200;
{
ElFilo<III> Fi(4);
INT i;
for ( i= 0; i<nb; i++)
Fi.pushlast(III(i));
for ( i= 0; i<nb; i++)
Fi[i].i() *= 2;
for ( i= 0; i<nb; i++)
BENCH_ASSERT(Fi[i].i() == 2*i);
for ( i= 2*(nb-1) ; i>= 2; i-= 2)
BENCH_ASSERT(Fi.poplast().i() == i);
BENCH_ASSERT(Fi.nb() == 1);
}
verif_memory_state(MC_INIT);
}
void BenchcDbleGrid
(
Pt2dr aP0In,Pt2dr aP1In,
REAL aStepDir,
ElDistortion22_Gen & aDist
)
{
//cDbleGrid aDGr(aP0In,aP1In,aStepDir,aDist);
Pt2dr stepDir2(aStepDir,aStepDir); // __NEW
cDbleGrid aDGr(false,aP0In,aP1In,stepDir2,aDist); // __NEW
for (REAL aX = aP0In.x ; aX<aP1In.x ; aX += aStepDir)
for (REAL aY = aP0In.y ; aY<aP1In.y ; aY += aStepDir)
{
REAL x = aX + NRrandom3() * aStepDir;
SetInRange(aP0In.x,x,aP1In.x);
REAL y = aY + NRrandom3() * aStepDir;
SetInRange(aP0In.y,y,aP1In.y);
Pt2dr aP(x,y);
Pt2dr aQ0 = aDist.Direct(aP);
Pt2dr aQ1 = aDGr.Direct(aP);
Pt2dr aR0 = aDist.Inverse(aQ0);
Pt2dr aR1 = aDist.Inverse(aQ1);
REAL aDQ = euclid(aQ0,aQ1);
REAL aDR = euclid(aR0,aP) + euclid(aR1,aP);
aDQ /= ElSquare(aStepDir);
aDR /= ElSquare(aStepDir);
BENCH_ASSERT(aDQ<0.1);
BENCH_ASSERT(aDR<0.1);
}
}
cBenchLeastSquare::cBenchLeastSquare
(
INT aNbVar,
INT aNbEq,
bool SomForm
) :
FoncNVarDer<REAL> (aNbVar),
mNbVar (aNbVar),
mNbEq (aNbEq),
mSys (aNbVar,aNbEq),
mSol (1),
mSolEps (aNbVar),
mTmpVF (aNbVar),
mDataTmpVF (mTmpVF.data())
{
Im1D_REAL8 aFLin(aNbVar);
REAL8* aDLin = aFLin.data();
for (INT iEq = 0 ; iEq < aNbEq ; iEq++)
{
for (INT iVar=0 ; iVar<aNbVar ; iVar++)
{
if (SomForm)
{
if (iEq<2*aNbVar)
aDLin[iVar] = (iVar==(iEq%mNbVar));
else
aDLin[iVar] = NRrandC() * (NRrandC()>0);
}
else
aDLin[iVar] = NRrandC();
}
mSys.PushEquation
(
aFLin,
NRrandC() * 1e3,
0.1 + NRrandom3()
);
}
bool Ok;
mSol = mSys.L2Solve(&Ok);
mResidu = mSys.L2SomResiduPond(mSol);
BENCH_ASSERT(Ok);
for (INT k=0 ; k< 200 ; k++)
{
ELISE_COPY
(
mSolEps.all_pts(),
mSol.in() + (frandr()-0.5),
mSolEps.out()
);
REAL ResEps = mSys.L2SomResiduPond(mSolEps);
// cout << (ResEps-mResidu) << " " << mResidu << "\n";
BENCH_ASSERT(ResEps>mResidu);
}
// getchar();
}
void VerifCorrelCNC
(
Pt2di aDec,
bool Pondered,
Im2D_REAL8 aCPad,
REAL anEps,
Im2D_REAL8 aCNC,
REAL aRatioSurf
)
{
REAL aS_CorFFT = ImCorrFromNrFFT(aCPad,aDec);
REAL aS,aS1,aS2,aS11,aS12,aS22;
Symb_FNum aP ( Pondered ?
trans(mPds1.in(0),aDec)*mPds2.in(0) :
trans(mIm1.inside(),aDec)
);
Symb_FNum aF1 (trans(mIm1.in(0),aDec));
Symb_FNum aF2 (mIm2.in(0));
ELISE_COPY
(
mIm1.all_pts(),
Virgule
(
1,aF1,aF2,
aF1*aF1,aF1*aF2,aF2*aF2
)*aP,
Virgule
(
Virgule(sigma(aS) ,sigma(aS1) ,sigma(aS2)),
Virgule(sigma(aS11),sigma(aS12),sigma(aS22))
)
);
if (! Pondered)
BENCH_ASSERT(std::abs(aS12-aS_CorFFT )<epsilon);
aS = std::max(aS,anEps);
aS1 /= aS;
aS2 /= aS;
aS11 = aS11/aS - aS1 * aS1 ;
aS12 = aS12/aS - aS1 * aS2 ;
aS22 = aS22/aS - aS2 * aS2 ;
REAL aCor = aS12 / sqrt(std::max(anEps,aS11*aS22));
if (aS<aRatioSurf)
{
aCor = -1 + (aCor+1) * (aS/aRatioSurf);
}
REAL aNCCorFFT = ImCorrFromNrFFT(aCNC,aDec);
BENCH_ASSERT(std::abs(aCor-aNCCorFFT)<epsilon);
}
void dist_chamfer_cabl(Im2D<U_INT1,INT> I,INT v_max)
{
Im2D<U_INT1,INT> I0(I.tx(),I.ty(),0);
ELISE_COPY(I0.all_pts(),I.in(),I0.out());
Chamfer::d32.im_dist(I);
INT nb_dif;
ELISE_COPY
(
I.all_pts(),
I0.in()!=(I.in()!=0),
sigma(nb_dif)
);
BENCH_ASSERT(nb_dif == 0);
INT tx = I.tx();
INT ty = I.ty();
U_INT1 ** d = I.data();
INT vmax = I.vmax()-1;
for (int x=1; x<tx-1 ; x++)
for (int y=1; y<ty-1 ; y++)
{
INT v;
if (d[y][x])
v = std::min3
(
std::min3(d[y+1][x-1]+3,d[y+1][x]+2,d[y+1][x+1]+3),
std::min3(d[y][x-1]+2,vmax,d[y][x+1]+2),
std::min3(d[y-1][x-1]+3,d[y-1][x]+2,d[y-1][x+1]+3)
);
else
v = 0;
BENCH_ASSERT(v == d[y][x]);
}
INT dif;
ELISE_COPY
(
I.all_pts(),
Abs
(
Min(I.in(),v_max)
- extinc_32(I0.in(0),v_max)
),
VMax(dif)
);
BENCH_ASSERT(dif == 0);
}
void bench_r2d_shading()
{
Pt2di sz(120,50);
Im2D_REAL8 MNT(sz.x,sz.y,0.0);
Im2D_REAL8 SHAD1(sz.x,sz.y,0.0);
Im2D_REAL8 SHAD2(sz.x,sz.y,0.0);
ELISE_COPY(MNT.all_pts(),frandr(),MNT.out());
ELISE_COPY
(
MNT.all_pts(),
binary_shading(MNT.in(),1.0),
SHAD1.out()
);
ELISE_COPY
(
MNT.lmr_all_pts(Pt2di(1,0)),
binary_shading(MNT.in(),1.0),
SHAD2.out()
);
REAL dif;
ELISE_COPY (MNT.all_pts(),Abs(SHAD1.in()-SHAD2.in()),VMax(dif));
BENCH_ASSERT(dif<epsilon);
ELISE_COPY
(
MNT.all_pts(),
gray_level_shading(MNT.in()),
SHAD1.out()
);
ELISE_COPY
(
MNT.lmr_all_pts(Pt2di(1,0)),
gray_level_shading(MNT.in()),
SHAD2.out()
);
ELISE_COPY (MNT.all_pts(),Abs(SHAD1.in()-SHAD2.in()),VMax(dif));
BENCH_ASSERT(dif<epsilon);
}
static int tensor_rowmajor_transposedp(bench_tensor *t)
{
bench_iodim *d;
int i;
BENCH_ASSERT(FINITE_RNK(t->rnk));
if (t->rnk < 2)
return 0;
d = t->dims;
if (d[0].is != d[1].is * d[1].n
|| d[0].os != d[1].is
|| d[1].os != d[0].os * d[0].n)
return 0;
if (t->rnk > 2 && d[1].is != d[2].is * d[2].n)
return 0;
for (i = 2; i + 1 < t->rnk; ++i) {
d = t->dims + i;
if (d[0].is != d[1].is * d[1].n
|| d[0].os != d[1].os * d[1].n)
return 0;
}
if (t->rnk > 2 && t->dims[t->rnk-1].is != t->dims[t->rnk-1].os)
return 0;
return 1;
}
void bench_dist_InerMat_seg_droite()
{
for (int i = 0; i<100 ; i++)
{
Pt2dr p1 = Pt2dr((NRrandom3()-0.5)*1e4,(NRrandom3()-0.5)*1e4);
Pt2dr p2 = p1;
while (euclid(p1-p2) < 1e2)
p2 = Pt2dr((NRrandom3()-0.5)*1e4,(NRrandom3()-0.5)*1e4);
SegComp s(p1,p2);
int nb = (int)(50 * NRrandom3());
REAL d0 = 0.0;
RMat_Inertie m;
for (int j =0; j<nb ; j++)
{
Pt2dr q = Pt2dr((NRrandom3()-0.5)*1e4,(NRrandom3()-0.5)*1e4);
REAL pds = NRrandom3();
m = m.plus_cple(q.x,q.y,pds);
d0 += pds * s.square_dist_droite(q);
}
REAL d1 = square_dist_droite(s,m);
BENCH_ASSERT(std::abs(d0 -d1) < BIG_epsilon);
}
}
static const char *parseint(const char *s, int *n)
{
int sign = 1;
*n = 0;
if (*s == '-') {
sign = -1;
++s;
} else if (*s == '+') {
sign = +1;
++s;
}
BENCH_ASSERT(isdigit(*s));
while (isdigit(*s)) {
*n = *n * 10 + (*s - '0');
++s;
}
*n *= sign;
if (*s == 'k' || *s == 'K') {
*n *= 1024;
++s;
}
if (*s == 'm' || *s == 'M') {
*n *= 1024 * 1024;
++s;
}
return s;
}
void setup(struct problem *p)
{
BENCH_ASSERT(can_do(p));
/* Call FFT once to initialize things before benchmarking: */
doit(1, p);
}
void rdwisdom(void)
{
FILE *f;
double tim;
int success = 0;
if (havewisdom) return;
#ifdef HAVE_SMP
BENCH_ASSERT(FFTW(init_threads)());
FFTW(plan_with_nthreads)(nthreads);
#endif
if (!usewisdom) return;
timer_start(USER_TIMER);
if ((f = fopen(wisdat, "r"))) {
if (!import_wisdom(f))
fprintf(stderr, "bench: ERROR reading wisdom\n");
else
success = 1;
fclose(f);
}
tim = timer_stop(USER_TIMER);
if (success) {
if (verbose > 1) printf("READ WISDOM (%g seconds): ", tim);
if (verbose > 3)
export_wisdom(stdout);
if (verbose > 1)
printf("\n");
}
havewisdom = 1;
}
/* detect screwy real padded rowmajor... ugh */
int tensor_real_rowmajorp(bench_tensor *t, int sign, int in_place)
{
int i;
BENCH_ASSERT(BENCH_FINITE_RNK(t->rnk));
i = t->rnk - 1;
if (--i >= 0) {
bench_iodim *d = t->dims + i;
if (sign < 0) {
if (d[0].is != d[1].is * (in_place ? 2*(d[1].n/2 + 1) : d[1].n))
return 0;
if (d[0].os != d[1].os * (d[1].n/2 + 1))
return 0;
}
else {
if (d[0].is != d[1].is * (d[1].n/2 + 1))
return 0;
if (d[0].os != d[1].os * (in_place ? 2*(d[1].n/2 + 1) : d[1].n))
return 0;
}
}
while (--i >= 0) {
bench_iodim *d = t->dims + i;
if (d[0].is != d[1].is * d[1].n)
return 0;
if (d[0].os != d[1].os * d[1].n)
return 0;
}
return 1;
}
void bench_dotens2(const bench_tensor *sz0, const bench_tensor *sz1, dotens2_closure *k)
{
BENCH_ASSERT(sz0->rnk == sz1->rnk);
if (sz0->rnk == BENCH_RNK_MINFTY)
return;
recur(sz0->rnk, sz0->dims, sz1->dims, k, 0, 0, 0, 0);
}
double timer_stop(int n)
{
mytime t1;
BENCH_ASSERT(n >= 0 && n < BENCH_NTIMERS);
t1 = get_time();
return elapsed(t1, t0[n]);
}
void bench_seg_mean_square()
{
for (int i = 0; i<100 ; i++)
{
INT nx = (INT) (10 +NRrandom3()*20);
INT ny = nx -5;
Pt2dr tr = Pt2dr((NRrandom3()-0.5)*1e4,(NRrandom3()-0.5)*1e4);
Pt2dr rot = Pt2dr::FromPolar(1.0,NRrandom3() *100);
RMat_Inertie m;
for (int x= -nx; x <= nx ; x++)
for (int y= -ny; y <= ny ; y++)
{
Pt2dr Z = tr+rot*Pt2dr(x,y);
m.add_pt_en_place(Z.x,Z.y);
}
Seg2d s = seg_mean_square(m,100.0);
Pt2dr cdg = s.p0();
Pt2dr all = (s.p1()-s.p0())/ 100.0;
BENCH_ASSERT
(
(euclid(cdg-tr) < BIG_epsilon)
&& (std::abs(all^rot) < BIG_epsilon)
);
// BENCH_ASSERT(Abs(d0 -d1) < BIG_epsilon);
}
}
void bench_im_reech
(
Fonc_Num Fonc,
Pt2di SzIm,
Fonc_Num reechantX,
Fonc_Num reechantY,
INT sz_grid,
REAL aMaxDif
)
{
Im2D_U_INT1 AnIm(SzIm.x,SzIm.y);
ELISE_COPY(AnIm.all_pts(),Fonc,AnIm.out());
REAL dif;
ELISE_COPY
(
AnIm.interior(3),
Abs
(
AnIm.ImGridReech (reechantX,reechantY,sz_grid,-100)
- Fonc[Virgule(reechantX,reechantY)]
),
VMax(dif)
);
BENCH_ASSERT(dif<aMaxDif);
}
void bench_least_square()
{
BenchcSysQuadCreuse();
bench_triviale_opt_sous_contrainte();
for (INT k=0 ; k<100 ; k++)
{
bench_opt_contrainte();
}
bool Ok;
SystLinSurResolu mSys(1,1);
Im1D_REAL8 aFlin(1,"2.0");
mSys.PushEquation(aFlin,3.0,1.0);
mSys.L2Solve(&Ok);
BENCH_ASSERT(Ok);
for (INT k=0 ; k< 200 ; k++)
{
bool SomForm = (k&1 ==0);
INT aNbVar = 2 + (INT)(10 * NRrandom3());
INT aNbEq = 2+aNbVar * (1 + (INT)(10 * NRrandom3()));
if (SomForm)
aNbEq += 10;
cBenchLeastSquare aBLS(aNbVar,aNbEq,SomForm);
aBLS.TestFoncNVar();
cout << k << "\n";
}
}
void Craig_etal_L1
(
Im2D_REAL8 A,
Im1D_REAL8 B,
REAL TOLER,
Im1D_REAL8 SOL,
Im1D_REAL8 RESIDU
)
{
INT n = SOL.tx();
INT m = B.tx();
BENCH_ASSERT
(
(A.tx() == n+2)
&& (A.ty() == m+2)
&& (B.tx() == m)
&& (SOL.tx() == n)
&& (RESIDU.tx() == m)
);
Craig_Barrodale_Roberts_l1
(
m,n,
A.data_lin(),
B.data(),
TOLER,
SOL.data(),
RESIDU.data()
);
}
void Optim_L1FormLin::BenchRand(INT NbVar,INT NbForm,INT NbTest,bool Comb)
{
Optim_L1FormLin OLF = RandOLF(NbVar,NbForm);
ElMatrix<REAL> Sol = OLF.Solve();
REAL ScS = OLF.score(Sol);
for (;NbTest>=0; NbTest --)
{
REAL eps = std::max(1e-3,0.2*ElSquare(NRrandom3()));
ElMatrix<REAL> D = Sol;
for (INT k=0 ; k<NbVar ; k++)
D(0,k) += eps * (NRrandom3()-0.5);
REAL sd = OLF.score(D);
if (ScS> sd)
{
if (Comb)
OLF.BenchCombin(ScS);
cout << ScS << " " << sd
<< " " << ((ScS-sd)/eps)
<< " " << eps << "\n";
BENCH_ASSERT(std::abs((ScS-sd)/eps) < 1e-7);
}
}
}
void bench_inter_Hor()
{
for (INT k=0; k<5000 ; k++)
{
Pt2dr p0 = random_pt();
Pt2dr p1 = random_pt();
if (std::abs(p0.y-p1.y)<1e-2)
p1.y += 1;
SegComp aSp(p0,p1);
REAL anY = NRrandom3() *100;
Pt2dr q0 (0,anY);
Pt2dr q1 (1,anY);
SegComp aSq(q0,q1);
bool OkInter;
Pt2dr aInter0 = aSp.inter(aSq,OkInter);
Pt2dr aInter2(aSp.AbsiceInterDroiteHoriz(anY),anY);
REAL DH = euclid(aInter0,aInter2) ;
BENCH_ASSERT(DH<BIG_epsilon);
}
}
void bench_i1_eq_i2(Im2D_U_INT1 i1,Im2D_U_INT1 i2)
{
INT nb_dif;
ELISE_COPY(i1.all_pts(),Abs(i1.in()-i2.in()),sigma(nb_dif));
BENCH_ASSERT(nb_dif ==0);
}
void bench_triviale_opt_sous_contrainte()
{
// Miminise x2+y2, sous la contrainte x+y=2
L2SysSurResol aSys(2);
double C[2] = {1,1};
aSys.GSSR_AddContrainte(C,3);
double Fx[2] = {1,0};
aSys.GSSR_AddNewEquation(1.0,Fx,0);
double Fy[2] = {0,1};
aSys.GSSR_AddNewEquation(1.0,Fy,0);
Im1D_REAL8 aSol = aSys.GSSR_Solve(0);
BENCH_ASSERT(std::abs(aSol.data()[0] -1.5)<epsilon);
BENCH_ASSERT(std::abs(aSol.data()[1] -1.5)<epsilon);
}
void problem_destroy(bench_problem *p)
{
BENCH_ASSERT(p);
problem_free(p);
bench_free0(p->k);
bench_free0(p->pstring);
bench_free(p);
}
static bool verif_equal(Im2D_U_INT1 Im1,Im2D_U_INT1 Im2)
{
INT Dif;
ELISE_COPY(Im1.all_pts(),Abs(Im1.in()-Im2.in()),sigma(Dif));
BENCH_ASSERT(Dif==0);
return Dif == 0;
}
void setup(struct problem *p)
{
int n, zero = 0;
BENCH_ASSERT(can_do(p));
switch (p->rank) {
case 1:
{
n = p->n[0];
if (p->kind == PROBLEM_COMPLEX) {
/*
* example code says that wsave consists of 3 * n
* locations, but the code dumps core for n == 4
*/
WSAVE = bench_malloc((3 * n + 4) * sizeof(bench_real));
if (SINGLE_PRECISION)
CFFT1D(p->in, &n, &zero, WSAVE);
else
ZFFT1D(p->in, &n, &zero, WSAVE);
} else {
WSAVE = bench_malloc((4 * n) * sizeof(bench_real));
if (p->sign == -1) {
if (SINGLE_PRECISION)
SCFFT1D(p->in, &n, &zero, WSAVE);
else
DZFFT1D(p->in, &n, &zero, WSAVE);
} else {
if (SINGLE_PRECISION)
CSFFT1D(p->in, &n, &zero, WSAVE);
else
ZDFFT1D(p->in, &n, &zero, WSAVE);
}
}
break;
}
case 2:
/* nothing to do */
break;
default:
BENCH_ASSERT(0);
}
}
void verify_rdft2(bench_problem *p, int rounds, double tol, errors *e)
{
C *inA, *inB, *inC, *outA, *outB, *outC, *tmp;
int n, vecn, N;
dofft_rdft2_closure k;
BENCH_ASSERT(p->kind == PROBLEM_REAL);
if (!FINITE_RNK(p->sz->rnk) || !FINITE_RNK(p->vecsz->rnk))
return; /* give up */
k.k.apply = rdft2_apply;
k.k.recopy_input = 0;
k.p = p;
if (rounds == 0)
rounds = 20; /* default value */
n = tensor_sz(p->sz);
vecn = tensor_sz(p->vecsz);
N = n * vecn;
inA = (C *) bench_malloc(N * sizeof(C));
inB = (C *) bench_malloc(N * sizeof(C));
inC = (C *) bench_malloc(N * sizeof(C));
outA = (C *) bench_malloc(N * sizeof(C));
outB = (C *) bench_malloc(N * sizeof(C));
outC = (C *) bench_malloc(N * sizeof(C));
tmp = (C *) bench_malloc(N * sizeof(C));
e->i = impulse(&k.k, n, vecn, inA, inB, inC, outA, outB, outC,
tmp, rounds, tol);
e->l = linear(&k.k, 1, N, inA, inB, inC, outA, outB, outC,
tmp, rounds, tol);
e->s = 0.0;
if (p->sign < 0)
e->s = dmax(e->s, tf_shift(&k.k, 1, p->sz, n, vecn, p->sign,
inA, inB, outA, outB,
tmp, rounds, tol, TIME_SHIFT));
else
e->s = dmax(e->s, tf_shift(&k.k, 1, p->sz, n, vecn, p->sign,
inA, inB, outA, outB,
tmp, rounds, tol, FREQ_SHIFT));
if (!p->in_place && !p->destroy_input)
preserves_input(&k.k, p->sign < 0 ? mkreal : mkhermitian1,
N, inA, inB, outB, rounds);
bench_free(tmp);
bench_free(outC);
bench_free(outB);
bench_free(outA);
bench_free(inC);
bench_free(inB);
bench_free(inA);
}
/* Like tensor_copy, but copy only rnk dimensions starting with start_dim. */
bench_tensor *tensor_copy_sub(const bench_tensor *sz, int start_dim, int rnk)
{
bench_tensor *x;
BENCH_ASSERT(BENCH_FINITE_RNK(sz->rnk) && start_dim + rnk <= sz->rnk);
x = mktensor(rnk);
dimcpy(x->dims, sz->dims + start_dim, rnk);
return x;
}
/* funny transformations for last dimension of PROBLEM_REAL */
static int transform_n(int n, n_transform nt)
{
switch (nt) {
case SAME: return n;
case PADDED: return 2*(n/2+1);
case HALFISH: return (n/2+1);
default: BENCH_ASSERT(0); return 0;
}
}
