自学教程：C++ BENCH_ASSERT函数代码示例

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);}

/* 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;     }}