public mincgstate() { _innerobj = new mincg.mincgstate(); }
public mincgstate(mincg.mincgstate obj) { _innerobj = obj; }
public static int Main(string[] args) { int n = 0; mincg.mincgstate state = new mincg.mincgstate(); mincg.mincgreport rep = new mincg.mincgreport(); double[] s = new double[0]; double x = 0; double y = 0; // // Function minimized: // F = exp(x-1) + exp(1-x) + (y-x)^2 // N = 2 - task dimension. // // Take a look at MinCGSetStpMax() call - it prevents us // from overflow (which may be result of too large step). // Try to comment it and see what will happen. // n = 2; s = new double[2]; s[0] = 10; s[1] = AP.Math.RandomReal()-0.5; mincg.mincgcreate(n, ref s, ref state); mincg.mincgsetcond(ref state, 0.0, 0.0, 0.0001, 0); mincg.mincgsetxrep(ref state, true); mincg.mincgsetstpmax(ref state, 1.0); System.Console.WriteLine(); System.Console.WriteLine(); System.Console.Write("F = exp(x-1) + exp(1-x) + (y-x)^2"); System.Console.WriteLine(); System.Console.Write("OPTIMIZATION STARTED"); System.Console.WriteLine(); while( mincg.mincgiteration(ref state) ) { if( state.needfg ) { x = state.x[0]; y = state.x[1]; state.f = Math.Exp(x-1)+Math.Exp(1-x)+AP.Math.Sqr(y-x); state.g[0] = Math.Exp(x-1)-Math.Exp(1-x)+2*(x-y); state.g[1] = 2*(y-x); } if( state.xupdated ) { System.Console.Write(" F("); System.Console.Write("{0,8:F5}",state.x[0]); System.Console.Write(","); System.Console.Write("{0,8:F5}",state.x[1]); System.Console.Write(")="); System.Console.Write("{0,0:F5}",state.f); System.Console.WriteLine(); } } System.Console.Write("OPTIMIZATION STOPPED"); System.Console.WriteLine(); mincg.mincgresults(ref state, ref s, ref rep); // // output results // System.Console.Write("X = "); System.Console.Write("{0,4:F2}",s[0]); System.Console.Write(" (should be 1.00)"); System.Console.WriteLine(); System.Console.Write("Y = "); System.Console.Write("{0,4:F2}",s[1]); System.Console.Write(" (should be 1.00)"); System.Console.WriteLine(); System.Console.WriteLine(); System.Console.WriteLine(); return 0; }
public minbleicstate() { diaghoriginal = new double[0]; diagh = new double[0]; x = new double[0]; g = new double[0]; rstate = new rcommstate(); xcur = new double[0]; xprev = new double[0]; xstart = new double[0]; xend = new double[0]; lastg = new double[0]; ceoriginal = new double[0,0]; ceeffective = new double[0,0]; cecurrent = new double[0,0]; ct = new int[0]; xe = new double[0]; hasbndl = new bool[0]; hasbndu = new bool[0]; bndloriginal = new double[0]; bnduoriginal = new double[0]; bndleffective = new double[0]; bndueffective = new double[0]; activeconstraints = new bool[0]; constrainedvalues = new double[0]; transforms = new double[0]; seffective = new double[0]; soriginal = new double[0]; w = new double[0]; tmp0 = new double[0]; tmp1 = new double[0]; tmp2 = new double[0]; r = new double[0]; lmmatrix = new double[0,0]; cgstate = new mincg.mincgstate(); cgrep = new mincg.mincgreport(); }
/************************************************************************* Other properties *************************************************************************/ public static void testother(ref bool err) { int n = 0; double[] x = new double[0]; double[] s = new double[0]; double[] a = new double[0]; double[] h = new double[0]; double[] xlast = new double[0]; double fprev = 0; double xprev = 0; double stpmax = 0; int i = 0; mincg.mincgstate state = new mincg.mincgstate(); mincg.mincgreport rep = new mincg.mincgreport(); int cgtype = 0; double tmpeps = 0; double epsg = 0; double v = 0; double r = 0; bool hasxlast = new bool(); double lastscaledstep = 0; int pkind = 0; int ckind = 0; int mkind = 0; int dkind = 0; double diffstep = 0; double vc = 0; double vm = 0; bool wasf = new bool(); bool wasfg = new bool(); int i_ = 0; for(cgtype=-1; cgtype<=1; cgtype++) { // // Test reports (F should form monotone sequence) // n = 50; x = new double[n]; xlast = new double[n]; for(i=0; i<=n-1; i++) { x[i] = 1; } mincg.mincgcreate(n, x, state); mincg.mincgsetcond(state, 0, 0, 0, 100); mincg.mincgsetxrep(state, true); fprev = math.maxrealnumber; while( mincg.mincgiteration(state) ) { if( state.needfg ) { state.f = 0; for(i=0; i<=n-1; i++) { state.f = state.f+math.sqr((1+i)*state.x[i]); state.g[i] = 2*(1+i)*state.x[i]; } } if( state.xupdated ) { err = err | (double)(state.f)>(double)(fprev); if( (double)(fprev)==(double)(math.maxrealnumber) ) { for(i=0; i<=n-1; i++) { err = err | (double)(state.x[i])!=(double)(x[i]); } } fprev = state.f; for(i_=0; i_<=n-1;i_++) { xlast[i_] = state.x[i_]; } } } mincg.mincgresults(state, ref x, rep); for(i=0; i<=n-1; i++) { err = err | (double)(x[i])!=(double)(xlast[i]); } // // Test differentiation vs. analytic gradient // (first one issues NeedF requests, second one issues NeedFG requests) // n = 50; diffstep = 1.0E-6; for(dkind=0; dkind<=1; dkind++) { x = new double[n]; xlast = new double[n]; for(i=0; i<=n-1; i++) { x[i] = 1; } if( dkind==0 ) { mincg.mincgcreate(n, x, state); } if( dkind==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcond(state, 0, 0, 0, n/2); wasf = false; wasfg = false; while( mincg.mincgiteration(state) ) { if( state.needf | state.needfg ) { state.f = 0; } for(i=0; i<=n-1; i++) { if( state.needf | state.needfg ) { state.f = state.f+math.sqr((1+i)*state.x[i]); } if( state.needfg ) { state.g[i] = 2*(1+i)*state.x[i]; } } wasf = wasf | state.needf; wasfg = wasfg | state.needfg; } mincg.mincgresults(state, ref x, rep); if( dkind==0 ) { err = (err | wasf) | !wasfg; } if( dkind==1 ) { err = (err | !wasf) | wasfg; } } // // Test that numerical differentiation uses scaling. // // In order to test that we solve simple optimization // problem: min(x^2) with initial x equal to 0.0. // // We choose random DiffStep and S, then we check that // optimizer evaluates function at +-DiffStep*S only. // x = new double[1]; s = new double[1]; diffstep = math.randomreal()*1.0E-6; s[0] = Math.Exp(math.randomreal()*4-2); x[0] = 0; mincg.mincgcreatef(1, x, diffstep, state); mincg.mincgsetcond(state, 1.0E-6, 0, 0, 0); mincg.mincgsetscale(state, s); v = 0; while( mincg.mincgiteration(state) ) { state.f = math.sqr(state.x[0]); v = Math.Max(v, Math.Abs(state.x[0])); } mincg.mincgresults(state, ref x, rep); r = v/(s[0]*diffstep); err = err | (double)(Math.Abs(Math.Log(r)))>(double)(Math.Log(1+1000*math.machineepsilon)); // // Test maximum step // n = 1; x = new double[n]; x[0] = 100; stpmax = 0.05+0.05*math.randomreal(); mincg.mincgcreate(n, x, state); mincg.mincgsetcond(state, 1.0E-9, 0, 0, 0); mincg.mincgsetstpmax(state, stpmax); mincg.mincgsetxrep(state, true); xprev = x[0]; while( mincg.mincgiteration(state) ) { if( state.needfg ) { state.f = Math.Exp(state.x[0])+Math.Exp(-state.x[0]); state.g[0] = Math.Exp(state.x[0])-Math.Exp(-state.x[0]); err = err | (double)(Math.Abs(state.x[0]-xprev))>(double)((1+Math.Sqrt(math.machineepsilon))*stpmax); } if( state.xupdated ) { err = err | (double)(Math.Abs(state.x[0]-xprev))>(double)((1+Math.Sqrt(math.machineepsilon))*stpmax); xprev = state.x[0]; } } // // Test correctness of the scaling: // * initial point is random point from [+1,+2]^N // * f(x) = SUM(A[i]*x[i]^4), C[i] is random from [0.01,100] // * we use random scaling matrix // * we test different variants of the preconditioning: // 0) unit preconditioner // 1) random diagonal from [0.01,100] // 2) scale preconditioner // * we set stringent stopping conditions (we try EpsG and EpsX) // * and we test that in the extremum stopping conditions are // satisfied subject to the current scaling coefficients. // tmpeps = 1.0E-10; for(n=1; n<=10; n++) { for(pkind=0; pkind<=2; pkind++) { x = new double[n]; xlast = new double[n]; a = new double[n]; s = new double[n]; h = new double[n]; for(i=0; i<=n-1; i++) { x[i] = math.randomreal()+1; a[i] = Math.Exp(Math.Log(100)*(2*math.randomreal()-1)); s[i] = Math.Exp(Math.Log(100)*(2*math.randomreal()-1)); h[i] = Math.Exp(Math.Log(100)*(2*math.randomreal()-1)); } mincg.mincgcreate(n, x, state); mincg.mincgsetscale(state, s); mincg.mincgsetxrep(state, true); if( pkind==1 ) { mincg.mincgsetprecdiag(state, h); } if( pkind==2 ) { mincg.mincgsetprecscale(state); } // // Test gradient-based stopping condition // for(i=0; i<=n-1; i++) { x[i] = math.randomreal()+1; } mincg.mincgsetcond(state, tmpeps, 0, 0, 0); mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { if( state.needfg ) { state.f = 0; for(i=0; i<=n-1; i++) { state.f = state.f+a[i]*Math.Pow(state.x[i], 4); state.g[i] = 4*a[i]*Math.Pow(state.x[i], 3); } } } mincg.mincgresults(state, ref x, rep); if( rep.terminationtype<=0 ) { err = true; return; } v = 0; for(i=0; i<=n-1; i++) { v = v+math.sqr(s[i]*4*a[i]*Math.Pow(x[i], 3)); } v = Math.Sqrt(v); err = err | (double)(v)>(double)(tmpeps); // // Test step-based stopping condition // for(i=0; i<=n-1; i++) { x[i] = math.randomreal()+1; } hasxlast = false; mincg.mincgsetcond(state, 0, 0, tmpeps, 0); mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { if( state.needfg ) { state.f = 0; for(i=0; i<=n-1; i++) { state.f = state.f+a[i]*Math.Pow(state.x[i], 4); state.g[i] = 4*a[i]*Math.Pow(state.x[i], 3); } } if( state.xupdated ) { if( hasxlast ) { lastscaledstep = 0; for(i=0; i<=n-1; i++) { lastscaledstep = lastscaledstep+math.sqr(state.x[i]-xlast[i])/math.sqr(s[i]); } lastscaledstep = Math.Sqrt(lastscaledstep); } else { lastscaledstep = 0; } for(i_=0; i_<=n-1;i_++) { xlast[i_] = state.x[i_]; } hasxlast = true; } } mincg.mincgresults(state, ref x, rep); if( rep.terminationtype<=0 ) { err = true; return; } err = err | (double)(lastscaledstep)>(double)(tmpeps); } } // // Check correctness of the "trimming". // // Trimming is a technique which is used to help algorithm // cope with unbounded functions. In order to check this // technique we will try to solve following optimization // problem: // // min f(x) subject to no constraints on X // { 1/(1-x) + 1/(1+x) + c*x, if -0.999999<x<0.999999 // f(x) = { // { M, if x<=-0.999999 or x>=0.999999 // // where c is either 1.0 or 1.0E+6, M is either 1.0E8, 1.0E20 or +INF // (we try different combinations) // for(ckind=0; ckind<=1; ckind++) { for(mkind=0; mkind<=2; mkind++) { // // Choose c and M // if( ckind==0 ) { vc = 1.0; } if( ckind==1 ) { vc = 1.0E+6; } if( mkind==0 ) { vm = 1.0E+8; } if( mkind==1 ) { vm = 1.0E+20; } if( mkind==2 ) { vm = Double.PositiveInfinity; } // // Create optimizer, solve optimization problem // epsg = 1.0E-6*vc; x = new double[1]; x[0] = 0.0; mincg.mincgcreate(1, x, state); mincg.mincgsetcond(state, epsg, 0, 0, 0); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { if( state.needfg ) { if( (double)(-0.999999)<(double)(state.x[0]) & (double)(state.x[0])<(double)(0.999999) ) { state.f = 1/(1-state.x[0])+1/(1+state.x[0])+vc*state.x[0]; state.g[0] = 1/math.sqr(1-state.x[0])-1/math.sqr(1+state.x[0])+vc; } else { state.f = vm; } } } mincg.mincgresults(state, ref x, rep); if( rep.terminationtype<=0 ) { err = true; return; } err = err | (double)(Math.Abs(1/math.sqr(1-x[0])-1/math.sqr(1+x[0])+vc))>(double)(epsg); } } } }
/************************************************************************* This function tests preconditioning On failure sets Err to True (leaves it unchanged otherwise) *************************************************************************/ private static void testpreconditioning(ref bool err) { int pass = 0; int n = 0; double[] x = new double[0]; double[] x0 = new double[0]; int i = 0; int j = 0; int k = 0; int vs = 0; double[,] v = new double[0,0]; double[] vd = new double[0]; double[] d = new double[0]; double[] s = new double[0]; int cntb1 = 0; int cntg1 = 0; int cntb2 = 0; int cntg2 = 0; double epsg = 0; double[] diagh = new double[0]; mincg.mincgstate state = new mincg.mincgstate(); mincg.mincgreport rep = new mincg.mincgreport(); int cgtype = 0; k = 50; epsg = 1.0E-10; for(cgtype=-1; cgtype<=1; cgtype++) { // // Preconditioner test 1. // // If // * B1 is default preconditioner // * G1 is diagonal precomditioner based on approximate diagonal of Hessian matrix // then "bad" preconditioner is worse than "good" one. // "Worse" means more iterations to converge. // // // We test it using f(x) = sum( ((i*i+1)*x[i])^2, i=0..N-1). // // N - problem size // K - number of repeated passes (should be large enough to average out random factors) // for(n=10; n<=15; n++) { x = new double[n]; for(i=0; i<=n-1; i++) { x[i] = 0; } mincg.mincgcreate(n, x, state); mincg.mincgsetcgtype(state, cgtype); // // Test it with default preconditioner // mincg.mincgsetprecdefault(state); cntb1 = 0; for(pass=0; pass<=k-1; pass++) { for(i=0; i<=n-1; i++) { x[i] = 2*math.randomreal()-1; } mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { calciip2(state, n); } mincg.mincgresults(state, ref x, rep); cntb1 = cntb1+rep.iterationscount; err = err | rep.terminationtype<=0; } // // Test it with perturbed diagonal preconditioner // diagh = new double[n]; for(i=0; i<=n-1; i++) { diagh[i] = 2*math.sqr(i*i+1)*(0.8+0.4*math.randomreal()); } mincg.mincgsetprecdiag(state, diagh); cntg1 = 0; for(pass=0; pass<=k-1; pass++) { for(i=0; i<=n-1; i++) { x[i] = 2*math.randomreal()-1; } mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { calciip2(state, n); } mincg.mincgresults(state, ref x, rep); cntg1 = cntg1+rep.iterationscount; err = err | rep.terminationtype<=0; } // // Compare // err = err | cntb1<cntg1; } // // Preconditioner test 2. // // If // * B1 is default preconditioner // * G1 is low rank exact preconditioner // then "bad" preconditioner is worse than "good" one. // "Worse" means more iterations to converge. // // Target function is f(x) = 0.5*(x-x0)'*A*(x-x0), A = D+V'*Vd*V // // N - problem size // K - number of repeated passes (should be large enough to average out random factors) // for(n=10; n<=15; n++) { for(vs=0; vs<=5; vs++) { x = new double[n]; x0 = new double[n]; d = new double[n]; for(i=0; i<=n-1; i++) { x[i] = 0; x0[i] = 2*math.randomreal()-1; d[i] = Math.Exp(2*math.randomreal()); } if( vs>0 ) { v = new double[vs, n]; vd = new double[vs]; for(i=0; i<=vs-1; i++) { for(j=0; j<=n-1; j++) { v[i,j] = 2*math.randomreal()-1; } vd[i] = Math.Exp(2*math.randomreal()); } } mincg.mincgcreate(n, x, state); mincg.mincgsetcgtype(state, cgtype); // // Test it with default preconditioner // mincg.mincgsetprecdefault(state); cntb1 = 0; for(pass=0; pass<=k-1; pass++) { for(i=0; i<=n-1; i++) { x[i] = 2*math.randomreal()-1; } mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { calclowrank(state, n, vs, d, v, vd, x0); } mincg.mincgresults(state, ref x, rep); cntb1 = cntb1+rep.iterationscount; err = err | rep.terminationtype<=0; } // // Test it with low rank preconditioner // mincg.mincgsetpreclowrankfast(state, d, vd, v, vs); cntg1 = 0; for(pass=0; pass<=k-1; pass++) { for(i=0; i<=n-1; i++) { x[i] = 2*math.randomreal()-1; } mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { calclowrank(state, n, vs, d, v, vd, x0); } mincg.mincgresults(state, ref x, rep); cntg1 = cntg1+rep.iterationscount; err = err | rep.terminationtype<=0; } // // Compare // err = err | cntb1<cntg1; } } // // Preconditioner test 3. // // If // * B2 is default preconditioner with non-unit scale S[i]=1/sqrt(h[i]) // * G2 is scale-based preconditioner with non-unit scale S[i]=1/sqrt(h[i]) // then B2 is worse than G2. // "Worse" means more iterations to converge. // for(n=10; n<=15; n++) { x = new double[n]; for(i=0; i<=n-1; i++) { x[i] = 0; } mincg.mincgcreate(n, x, state); s = new double[n]; for(i=0; i<=n-1; i++) { s[i] = 1/Math.Sqrt(2*Math.Pow(i*i+1, 2)*(0.8+0.4*math.randomreal())); } mincg.mincgsetprecdefault(state); mincg.mincgsetscale(state, s); cntb2 = 0; for(pass=0; pass<=k-1; pass++) { for(i=0; i<=n-1; i++) { x[i] = 2*math.randomreal()-1; } mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { calciip2(state, n); } mincg.mincgresults(state, ref x, rep); cntb2 = cntb2+rep.iterationscount; err = err | rep.terminationtype<=0; } mincg.mincgsetprecscale(state); mincg.mincgsetscale(state, s); cntg2 = 0; for(pass=0; pass<=k-1; pass++) { for(i=0; i<=n-1; i++) { x[i] = 2*math.randomreal()-1; } mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { calciip2(state, n); } mincg.mincgresults(state, ref x, rep); cntg2 = cntg2+rep.iterationscount; err = err | rep.terminationtype<=0; } err = err | cntb2<cntg2; } } }
public static bool testmincg(bool silent) { bool result = new bool(); bool waserrors = new bool(); bool referror = new bool(); bool eqerror = new bool(); bool linerror1 = new bool(); bool linerror2 = new bool(); bool restartserror = new bool(); bool precerror = new bool(); bool converror = new bool(); bool othererrors = new bool(); int n = 0; double[] x = new double[0]; double[] xe = new double[0]; double[] b = new double[0]; double[] xlast = new double[0]; int i = 0; int j = 0; double v = 0; double[,] a = new double[0,0]; double[] diagh = new double[0]; mincg.mincgstate state = new mincg.mincgstate(); mincg.mincgreport rep = new mincg.mincgreport(); int cgtype = 0; int difftype = 0; double diffstep = 0; int i_ = 0; waserrors = false; referror = false; linerror1 = false; linerror2 = false; eqerror = false; converror = false; restartserror = false; othererrors = false; precerror = false; testpreconditioning(ref precerror); testother(ref othererrors); for(difftype=0; difftype<=1; difftype++) { for(cgtype=-1; cgtype<=1; cgtype++) { // // Reference problem // x = new double[2+1]; n = 3; diffstep = 1.0E-6; x[0] = 100*math.randomreal()-50; x[1] = 100*math.randomreal()-50; x[2] = 100*math.randomreal()-50; if( difftype==0 ) { mincg.mincgcreate(n, x, state); } if( difftype==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { if( state.needf | state.needfg ) { state.f = math.sqr(state.x[0]-2)+math.sqr(state.x[1])+math.sqr(state.x[2]-state.x[0]); } if( state.needfg ) { state.g[0] = 2*(state.x[0]-2)+2*(state.x[0]-state.x[2]); state.g[1] = 2*state.x[1]; state.g[2] = 2*(state.x[2]-state.x[0]); } } mincg.mincgresults(state, ref x, rep); referror = (((referror | rep.terminationtype<=0) | (double)(Math.Abs(x[0]-2))>(double)(0.001)) | (double)(Math.Abs(x[1]))>(double)(0.001)) | (double)(Math.Abs(x[2]-2))>(double)(0.001); // // F2 problem with restarts: // * make several iterations and restart BEFORE termination // * iterate and restart AFTER termination // // NOTE: step is bounded from above to avoid premature convergence // x = new double[3]; n = 3; diffstep = 1.0E-6; x[0] = 10+10*math.randomreal(); x[1] = 10+10*math.randomreal(); x[2] = 10+10*math.randomreal(); if( difftype==0 ) { mincg.mincgcreate(n, x, state); } if( difftype==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcgtype(state, cgtype); mincg.mincgsetstpmax(state, 0.1); mincg.mincgsetcond(state, 0.0000001, 0.0, 0.0, 0); for(i=0; i<=10; i++) { if( !mincg.mincgiteration(state) ) { break; } testfunc2(state); } x[0] = 10+10*math.randomreal(); x[1] = 10+10*math.randomreal(); x[2] = 10+10*math.randomreal(); mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { testfunc2(state); } mincg.mincgresults(state, ref x, rep); restartserror = (((restartserror | rep.terminationtype<=0) | (double)(Math.Abs(x[0]-Math.Log(2)))>(double)(0.01)) | (double)(Math.Abs(x[1]))>(double)(0.01)) | (double)(Math.Abs(x[2]-Math.Log(2)))>(double)(0.01); x[0] = 10+10*math.randomreal(); x[1] = 10+10*math.randomreal(); x[2] = 10+10*math.randomreal(); mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { testfunc2(state); } mincg.mincgresults(state, ref x, rep); restartserror = (((restartserror | rep.terminationtype<=0) | (double)(Math.Abs(x[0]-Math.Log(2)))>(double)(0.01)) | (double)(Math.Abs(x[1]))>(double)(0.01)) | (double)(Math.Abs(x[2]-Math.Log(2)))>(double)(0.01); // // 1D problem #1 // x = new double[0+1]; n = 1; diffstep = 1.0E-6; x[0] = 100*math.randomreal()-50; if( difftype==0 ) { mincg.mincgcreate(n, x, state); } if( difftype==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { if( state.needf | state.needfg ) { state.f = -Math.Cos(state.x[0]); } if( state.needfg ) { state.g[0] = Math.Sin(state.x[0]); } } mincg.mincgresults(state, ref x, rep); linerror1 = (linerror1 | rep.terminationtype<=0) | (double)(Math.Abs(x[0]/Math.PI-(int)Math.Round(x[0]/Math.PI)))>(double)(0.001); // // 1D problem #2 // x = new double[0+1]; n = 1; diffstep = 1.0E-6; x[0] = 100*math.randomreal()-50; if( difftype==0 ) { mincg.mincgcreate(n, x, state); } if( difftype==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { if( state.needf | state.needfg ) { state.f = math.sqr(state.x[0])/(1+math.sqr(state.x[0])); } if( state.needfg ) { state.g[0] = (2*state.x[0]*(1+math.sqr(state.x[0]))-math.sqr(state.x[0])*2*state.x[0])/math.sqr(1+math.sqr(state.x[0])); } } mincg.mincgresults(state, ref x, rep); linerror2 = (linerror2 | rep.terminationtype<=0) | (double)(Math.Abs(x[0]))>(double)(0.001); // // Linear equations // diffstep = 1.0E-6; for(n=1; n<=10; n++) { // // Prepare task // a = new double[n-1+1, n-1+1]; x = new double[n-1+1]; xe = new double[n-1+1]; b = new double[n-1+1]; for(i=0; i<=n-1; i++) { xe[i] = 2*math.randomreal()-1; } for(i=0; i<=n-1; i++) { for(j=0; j<=n-1; j++) { a[i,j] = 2*math.randomreal()-1; } a[i,i] = a[i,i]+3*Math.Sign(a[i,i]); } for(i=0; i<=n-1; i++) { v = 0.0; for(i_=0; i_<=n-1;i_++) { v += a[i,i_]*xe[i_]; } b[i] = v; } // // Solve task // for(i=0; i<=n-1; i++) { x[i] = 2*math.randomreal()-1; } if( difftype==0 ) { mincg.mincgcreate(n, x, state); } if( difftype==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { if( state.needf | state.needfg ) { state.f = 0; } if( state.needfg ) { for(i=0; i<=n-1; i++) { state.g[i] = 0; } } for(i=0; i<=n-1; i++) { v = 0.0; for(i_=0; i_<=n-1;i_++) { v += a[i,i_]*state.x[i_]; } if( state.needf | state.needfg ) { state.f = state.f+math.sqr(v-b[i]); } if( state.needfg ) { for(j=0; j<=n-1; j++) { state.g[j] = state.g[j]+2*(v-b[i])*a[i,j]; } } } } mincg.mincgresults(state, ref x, rep); eqerror = eqerror | rep.terminationtype<=0; for(i=0; i<=n-1; i++) { eqerror = eqerror | (double)(Math.Abs(x[i]-xe[i]))>(double)(0.001); } } // // Testing convergence properties // diffstep = 1.0E-6; n = 3; x = new double[n]; for(i=0; i<=n-1; i++) { x[i] = 6*math.randomreal()-3; } if( difftype==0 ) { mincg.mincgcreate(n, x, state); } if( difftype==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcond(state, 0.001, 0.0, 0.0, 0); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { testfunc3(state); } mincg.mincgresults(state, ref x, rep); converror = converror | rep.terminationtype!=4; for(i=0; i<=n-1; i++) { x[i] = 6*math.randomreal()-3; } if( difftype==0 ) { mincg.mincgcreate(n, x, state); } if( difftype==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcond(state, 0.0, 0.001, 0.0, 0); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { testfunc3(state); } mincg.mincgresults(state, ref x, rep); converror = converror | rep.terminationtype!=1; for(i=0; i<=n-1; i++) { x[i] = 6*math.randomreal()-3; } if( difftype==0 ) { mincg.mincgcreate(n, x, state); } if( difftype==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcond(state, 0.0, 0.0, 0.001, 0); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { testfunc3(state); } mincg.mincgresults(state, ref x, rep); converror = converror | rep.terminationtype!=2; for(i=0; i<=n-1; i++) { x[i] = 2*math.randomreal()-1; } if( difftype==0 ) { mincg.mincgcreate(n, x, state); } if( difftype==1 ) { mincg.mincgcreatef(n, x, diffstep, state); } mincg.mincgsetcond(state, 0.0, 0.0, 0.0, 10); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { testfunc3(state); } mincg.mincgresults(state, ref x, rep); converror = converror | !((rep.terminationtype==5 & rep.iterationscount==10) | rep.terminationtype==7); } } // // end // waserrors = ((((((referror | eqerror) | linerror1) | linerror2) | converror) | othererrors) | restartserror) | precerror; if( !silent ) { System.Console.Write("TESTING CG OPTIMIZATION"); System.Console.WriteLine(); System.Console.Write("REFERENCE PROBLEM: "); if( referror ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("LIN-1 PROBLEM: "); if( linerror1 ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("LIN-2 PROBLEM: "); if( linerror2 ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("LINEAR EQUATIONS: "); if( eqerror ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("RESTARTS: "); if( restartserror ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("PRECONDITIONING: "); if( precerror ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("CONVERGENCE PROPERTIES: "); if( converror ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("OTHER PROPERTIES: "); if( othererrors ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } if( waserrors ) { System.Console.Write("TEST FAILED"); System.Console.WriteLine(); } else { System.Console.Write("TEST PASSED"); System.Console.WriteLine(); } System.Console.WriteLine(); System.Console.WriteLine(); } result = !waserrors; return result; }
public static int Main(string[] args) { int n = 0; mincg.mincgstate state = new mincg.mincgstate(); mincg.mincgreport rep = new mincg.mincgreport(); double[] s = new double[0]; double x = 0; double y = 0; // // Function minimized: // F = exp(x-1) + exp(1-x) + (y-x)^2 // N = 2 - task dimension. // // Take a look at MinCGSetStpMax() call - it prevents us // from overflow (which may be result of too large step). // Try to comment it and see what will happen. // n = 2; s = new double[2]; s[0] = 10; s[1] = AP.Math.RandomReal() - 0.5; mincg.mincgcreate(n, ref s, ref state); mincg.mincgsetcond(ref state, 0.0, 0.0, 0.0001, 0); mincg.mincgsetxrep(ref state, true); mincg.mincgsetstpmax(ref state, 1.0); System.Console.WriteLine(); System.Console.WriteLine(); System.Console.Write("F = exp(x-1) + exp(1-x) + (y-x)^2"); System.Console.WriteLine(); System.Console.Write("OPTIMIZATION STARTED"); System.Console.WriteLine(); while (mincg.mincgiteration(ref state)) { if (state.needfg) { x = state.x[0]; y = state.x[1]; state.f = Math.Exp(x - 1) + Math.Exp(1 - x) + AP.Math.Sqr(y - x); state.g[0] = Math.Exp(x - 1) - Math.Exp(1 - x) + 2 * (x - y); state.g[1] = 2 * (y - x); } if (state.xupdated) { System.Console.Write(" F("); System.Console.Write("{0,8:F5}", state.x[0]); System.Console.Write(","); System.Console.Write("{0,8:F5}", state.x[1]); System.Console.Write(")="); System.Console.Write("{0,0:F5}", state.f); System.Console.WriteLine(); } } System.Console.Write("OPTIMIZATION STOPPED"); System.Console.WriteLine(); mincg.mincgresults(ref state, ref s, ref rep); // // output results // System.Console.Write("X = "); System.Console.Write("{0,4:F2}", s[0]); System.Console.Write(" (should be 1.00)"); System.Console.WriteLine(); System.Console.Write("Y = "); System.Console.Write("{0,4:F2}", s[1]); System.Console.Write(" (should be 1.00)"); System.Console.WriteLine(); System.Console.WriteLine(); System.Console.WriteLine(); return(0); }
public static int Main(string[] args) { int n = 0; mincg.mincgstate state = new mincg.mincgstate(); mincg.mincgreport rep = new mincg.mincgreport(); double[] s = new double[0]; double x = 0; double y = 0; // // Function minimized: // F = (x-1)^4 + (y-x)^2 // N = 2 - task dimension. // n = 2; s = new double[2]; s[0] = 10; s[1] = 11; mincg.mincgcreate(n, ref s, ref state); mincg.mincgsetcond(ref state, 0.0, 0.0, 0.00001, 0); mincg.mincgsetxrep(ref state, true); System.Console.WriteLine(); System.Console.WriteLine(); System.Console.Write("F = (x-1)^4 + (y-x)^2"); System.Console.WriteLine(); System.Console.Write("OPTIMIZATION STARTED"); System.Console.WriteLine(); while( mincg.mincgiteration(ref state) ) { if( state.needfg ) { x = state.x[0]; y = state.x[1]; state.f = AP.Math.Sqr(AP.Math.Sqr(x-1))+AP.Math.Sqr(y-x); state.g[0] = 4*AP.Math.Sqr(x-1)*(x-1)+2*(x-y); state.g[1] = 2*(y-x); } if( state.xupdated ) { System.Console.Write(" F("); System.Console.Write("{0,8:F5}",state.x[0]); System.Console.Write(","); System.Console.Write("{0,8:F5}",state.x[1]); System.Console.Write(")="); System.Console.Write("{0,0:F5}",state.f); System.Console.WriteLine(); } } System.Console.Write("OPTIMIZATION STOPPED"); System.Console.WriteLine(); mincg.mincgresults(ref state, ref s, ref rep); // // output results // System.Console.Write("X = "); System.Console.Write("{0,4:F2}",s[0]); System.Console.Write(" (should be 1.00)"); System.Console.WriteLine(); System.Console.Write("Y = "); System.Console.Write("{0,4:F2}",s[1]); System.Console.Write(" (should be 1.00)"); System.Console.WriteLine(); System.Console.WriteLine(); System.Console.WriteLine(); return 0; }
public static int Main(string[] args) { int n = 0; mincg.mincgstate state = new mincg.mincgstate(); mincg.mincgreport rep = new mincg.mincgreport(); double[] s = new double[0]; double x = 0; double y = 0; // // Function minimized: // F = (x-1)^4 + (y-x)^2 // N = 2 - task dimension. // n = 2; s = new double[2]; s[0] = 10; s[1] = 11; mincg.mincgcreate(n, ref s, ref state); mincg.mincgsetcond(ref state, 0.0, 0.0, 0.00001, 0); mincg.mincgsetxrep(ref state, true); System.Console.WriteLine(); System.Console.WriteLine(); System.Console.Write("F = (x-1)^4 + (y-x)^2"); System.Console.WriteLine(); System.Console.Write("OPTIMIZATION STARTED"); System.Console.WriteLine(); while (mincg.mincgiteration(ref state)) { if (state.needfg) { x = state.x[0]; y = state.x[1]; state.f = AP.Math.Sqr(AP.Math.Sqr(x - 1)) + AP.Math.Sqr(y - x); state.g[0] = 4 * AP.Math.Sqr(x - 1) * (x - 1) + 2 * (x - y); state.g[1] = 2 * (y - x); } if (state.xupdated) { System.Console.Write(" F("); System.Console.Write("{0,8:F5}", state.x[0]); System.Console.Write(","); System.Console.Write("{0,8:F5}", state.x[1]); System.Console.Write(")="); System.Console.Write("{0,0:F5}", state.f); System.Console.WriteLine(); } } System.Console.Write("OPTIMIZATION STOPPED"); System.Console.WriteLine(); mincg.mincgresults(ref state, ref s, ref rep); // // output results // System.Console.Write("X = "); System.Console.Write("{0,4:F2}", s[0]); System.Console.Write(" (should be 1.00)"); System.Console.WriteLine(); System.Console.Write("Y = "); System.Console.Write("{0,4:F2}", s[1]); System.Console.Write(" (should be 1.00)"); System.Console.WriteLine(); System.Console.WriteLine(); System.Console.WriteLine(); return(0); }
public static bool testmincg(bool silent) { bool result = new bool(); bool waserrors = new bool(); bool referror = new bool(); bool eqerror = new bool(); bool linerror1 = new bool(); bool linerror2 = new bool(); bool restartserror = new bool(); bool converror = new bool(); bool othererrors = new bool(); int n = 0; double[] x = new double[0]; double[] xe = new double[0]; double[] b = new double[0]; double[] xlast = new double[0]; double fprev = 0; double xprev = 0; double stpmax = 0; int i = 0; int j = 0; double v = 0; double[,] a = new double[0,0]; mincg.mincgstate state = new mincg.mincgstate(); mincg.mincgreport rep = new mincg.mincgreport(); int cgtype = 0; int i_ = 0; waserrors = false; referror = false; linerror1 = false; linerror2 = false; eqerror = false; converror = false; restartserror = false; othererrors = false; for(cgtype=0; cgtype<=1; cgtype++) { // // Reference problem // x = new double[2+1]; n = 3; x[0] = 100*math.randomreal()-50; x[1] = 100*math.randomreal()-50; x[2] = 100*math.randomreal()-50; mincg.mincgcreate(n, x, state); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { state.f = math.sqr(state.x[0]-2)+math.sqr(state.x[1])+math.sqr(state.x[2]-state.x[0]); state.g[0] = 2*(state.x[0]-2)+2*(state.x[0]-state.x[2]); state.g[1] = 2*state.x[1]; state.g[2] = 2*(state.x[2]-state.x[0]); } mincg.mincgresults(state, ref x, rep); referror = (((referror | rep.terminationtype<=0) | (double)(Math.Abs(x[0]-2))>(double)(0.001)) | (double)(Math.Abs(x[1]))>(double)(0.001)) | (double)(Math.Abs(x[2]-2))>(double)(0.001); // // F2 problem with restarts: // * make several iterations and restart BEFORE termination // * iterate and restart AFTER termination // // NOTE: step is bounded from above to avoid premature convergence // x = new double[3]; n = 3; x[0] = 10+10*math.randomreal(); x[1] = 10+10*math.randomreal(); x[2] = 10+10*math.randomreal(); mincg.mincgcreate(n, x, state); mincg.mincgsetcgtype(state, cgtype); mincg.mincgsetstpmax(state, 0.1); mincg.mincgsetcond(state, 0.0000001, 0.0, 0.0, 0); for(i=0; i<=10; i++) { if( !mincg.mincgiteration(state) ) { break; } testfunc2(state); } x[0] = 10+10*math.randomreal(); x[1] = 10+10*math.randomreal(); x[2] = 10+10*math.randomreal(); mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { testfunc2(state); } mincg.mincgresults(state, ref x, rep); restartserror = (((restartserror | rep.terminationtype<=0) | (double)(Math.Abs(x[0]-Math.Log(2)))>(double)(0.01)) | (double)(Math.Abs(x[1]))>(double)(0.01)) | (double)(Math.Abs(x[2]-Math.Log(2)))>(double)(0.01); x[0] = 10+10*math.randomreal(); x[1] = 10+10*math.randomreal(); x[2] = 10+10*math.randomreal(); mincg.mincgrestartfrom(state, x); while( mincg.mincgiteration(state) ) { testfunc2(state); } mincg.mincgresults(state, ref x, rep); restartserror = (((restartserror | rep.terminationtype<=0) | (double)(Math.Abs(x[0]-Math.Log(2)))>(double)(0.01)) | (double)(Math.Abs(x[1]))>(double)(0.01)) | (double)(Math.Abs(x[2]-Math.Log(2)))>(double)(0.01); // // 1D problem #1 // x = new double[0+1]; n = 1; x[0] = 100*math.randomreal()-50; mincg.mincgcreate(n, x, state); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { state.f = -Math.Cos(state.x[0]); state.g[0] = Math.Sin(state.x[0]); } mincg.mincgresults(state, ref x, rep); linerror1 = (linerror1 | rep.terminationtype<=0) | (double)(Math.Abs(x[0]/Math.PI-(int)Math.Round(x[0]/Math.PI)))>(double)(0.001); // // 1D problem #2 // x = new double[0+1]; n = 1; x[0] = 100*math.randomreal()-50; mincg.mincgcreate(n, x, state); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { state.f = math.sqr(state.x[0])/(1+math.sqr(state.x[0])); state.g[0] = (2*state.x[0]*(1+math.sqr(state.x[0]))-math.sqr(state.x[0])*2*state.x[0])/math.sqr(1+math.sqr(state.x[0])); } mincg.mincgresults(state, ref x, rep); linerror2 = (linerror2 | rep.terminationtype<=0) | (double)(Math.Abs(x[0]))>(double)(0.001); // // Linear equations // for(n=1; n<=10; n++) { // // Prepare task // a = new double[n-1+1, n-1+1]; x = new double[n-1+1]; xe = new double[n-1+1]; b = new double[n-1+1]; for(i=0; i<=n-1; i++) { xe[i] = 2*math.randomreal()-1; } for(i=0; i<=n-1; i++) { for(j=0; j<=n-1; j++) { a[i,j] = 2*math.randomreal()-1; } a[i,i] = a[i,i]+3*Math.Sign(a[i,i]); } for(i=0; i<=n-1; i++) { v = 0.0; for(i_=0; i_<=n-1;i_++) { v += a[i,i_]*xe[i_]; } b[i] = v; } // // Solve task // for(i=0; i<=n-1; i++) { x[i] = 2*math.randomreal()-1; } mincg.mincgcreate(n, x, state); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { state.f = 0; for(i=0; i<=n-1; i++) { state.g[i] = 0; } for(i=0; i<=n-1; i++) { v = 0.0; for(i_=0; i_<=n-1;i_++) { v += a[i,i_]*state.x[i_]; } state.f = state.f+math.sqr(v-b[i]); for(j=0; j<=n-1; j++) { state.g[j] = state.g[j]+2*(v-b[i])*a[i,j]; } } } mincg.mincgresults(state, ref x, rep); eqerror = eqerror | rep.terminationtype<=0; for(i=0; i<=n-1; i++) { eqerror = eqerror | (double)(Math.Abs(x[i]-xe[i]))>(double)(0.001); } } // // Testing convergence properties // x = new double[2+1]; n = 3; for(i=0; i<=2; i++) { x[i] = 6*math.randomreal()-3; } mincg.mincgcreate(n, x, state); mincg.mincgsetcond(state, 0.001, 0.0, 0.0, 0); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { testfunc3(state); } mincg.mincgresults(state, ref x, rep); converror = converror | rep.terminationtype!=4; for(i=0; i<=2; i++) { x[i] = 6*math.randomreal()-3; } mincg.mincgcreate(n, x, state); mincg.mincgsetcond(state, 0.0, 0.001, 0.0, 0); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { testfunc3(state); } mincg.mincgresults(state, ref x, rep); converror = converror | rep.terminationtype!=1; for(i=0; i<=2; i++) { x[i] = 6*math.randomreal()-3; } mincg.mincgcreate(n, x, state); mincg.mincgsetcond(state, 0.0, 0.0, 0.001, 0); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { testfunc3(state); } mincg.mincgresults(state, ref x, rep); converror = converror | rep.terminationtype!=2; for(i=0; i<=2; i++) { x[i] = 2*math.randomreal()-1; } mincg.mincgcreate(n, x, state); mincg.mincgsetcond(state, 0.0, 0.0, 0.0, 10); mincg.mincgsetcgtype(state, cgtype); while( mincg.mincgiteration(state) ) { testfunc3(state); } mincg.mincgresults(state, ref x, rep); converror = converror | !((rep.terminationtype==5 & rep.iterationscount==10) | rep.terminationtype==7); // // Other properties: // 1. test reports (F should form monotone sequence) // 2. test maximum step // n = 50; x = new double[n]; xlast = new double[n]; for(i=0; i<=n-1; i++) { x[i] = 1; } mincg.mincgcreate(n, x, state); mincg.mincgsetcond(state, 0, 0, 0, 100); mincg.mincgsetxrep(state, true); fprev = math.maxrealnumber; while( mincg.mincgiteration(state) ) { if( state.needfg ) { state.f = 0; for(i=0; i<=n-1; i++) { state.f = state.f+math.sqr((1+i)*state.x[i]); state.g[i] = 2*(1+i)*state.x[i]; } } if( state.xupdated ) { othererrors = othererrors | (double)(state.f)>(double)(fprev); if( (double)(fprev)==(double)(math.maxrealnumber) ) { for(i=0; i<=n-1; i++) { othererrors = othererrors | (double)(state.x[i])!=(double)(x[i]); } } fprev = state.f; for(i_=0; i_<=n-1;i_++) { xlast[i_] = state.x[i_]; } } } mincg.mincgresults(state, ref x, rep); for(i=0; i<=n-1; i++) { othererrors = othererrors | (double)(x[i])!=(double)(xlast[i]); } n = 1; x = new double[n]; x[0] = 100; stpmax = 0.05+0.05*math.randomreal(); mincg.mincgcreate(n, x, state); mincg.mincgsetcond(state, 1.0E-9, 0, 0, 0); mincg.mincgsetstpmax(state, stpmax); mincg.mincgsetxrep(state, true); xprev = x[0]; while( mincg.mincgiteration(state) ) { if( state.needfg ) { state.f = Math.Exp(state.x[0])+Math.Exp(-state.x[0]); state.g[0] = Math.Exp(state.x[0])-Math.Exp(-state.x[0]); othererrors = othererrors | (double)(Math.Abs(state.x[0]-xprev))>(double)((1+Math.Sqrt(math.machineepsilon))*stpmax); } if( state.xupdated ) { othererrors = othererrors | (double)(Math.Abs(state.x[0]-xprev))>(double)((1+Math.Sqrt(math.machineepsilon))*stpmax); xprev = state.x[0]; } } } // // end // waserrors = (((((referror | eqerror) | linerror1) | linerror2) | converror) | othererrors) | restartserror; if( !silent ) { System.Console.Write("TESTING CG OPTIMIZATION"); System.Console.WriteLine(); System.Console.Write("REFERENCE PROBLEM: "); if( referror ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("LIN-1 PROBLEM: "); if( linerror1 ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("LIN-2 PROBLEM: "); if( linerror2 ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("LINEAR EQUATIONS: "); if( eqerror ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("RESTARTS: "); if( restartserror ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("CONVERGENCE PROPERTIES: "); if( converror ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("OTHER PROPERTIES: "); if( othererrors ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } if( waserrors ) { System.Console.Write("TEST FAILED"); System.Console.WriteLine(); } else { System.Console.Write("TEST PASSED"); System.Console.WriteLine(); } System.Console.WriteLine(); System.Console.WriteLine(); } result = !waserrors; return result; }