public nleqstate() { _innerobj = new nleq.nleqstate(); }
public nleqstate(nleq.nleqstate obj) { _innerobj = obj; }
public static bool testnleq(bool silent) { bool result = new bool(); bool waserrors = new bool(); bool basicserrors = new bool(); bool converror = new bool(); bool othererrors = new bool(); int n = 0; double[] x = new double[0]; int i = 0; int k = 0; double v = 0; double flast = 0; double[] xlast = new double[0]; bool firstrep = new bool(); int nfunc = 0; int njac = 0; int itcnt = 0; nleq.nleqstate state = new nleq.nleqstate(); nleq.nleqreport rep = new nleq.nleqreport(); int pass = 0; int passcount = 0; double epsf = 0; double stpmax = 0; int i_ = 0; waserrors = false; basicserrors = false; converror = false; othererrors = false; // // Basic tests // // Test with Himmelblau's function (M): // * ability to find correct result // * ability to work after soft restart (restart after finish) // * ability to work after hard restart (restart in the middle of optimization) // passcount = 100; for(pass=0; pass<=passcount-1; pass++) { // // Ability to find correct result // x = new double[2]; x[0] = 20*math.randomreal()-10; x[1] = 20*math.randomreal()-10; nleq.nleqcreatelm(2, 2, x, state); epsf = 1.0E-9; nleq.nleqsetcond(state, epsf, 0); while( nleq.nleqiteration(state) ) { testfunchbm(state); } nleq.nleqresults(state, ref x, rep); if( rep.terminationtype>0 ) { basicserrors = basicserrors | (double)(math.sqr(x[0]*x[0]+x[1]-11)+math.sqr(x[0]+x[1]*x[1]-7))>(double)(math.sqr(epsf)); } else { basicserrors = true; } // // Ability to work after soft restart // x = new double[2]; x[0] = 20*math.randomreal()-10; x[1] = 20*math.randomreal()-10; nleq.nleqcreatelm(2, 2, x, state); epsf = 1.0E-9; nleq.nleqsetcond(state, epsf, 0); while( nleq.nleqiteration(state) ) { testfunchbm(state); } nleq.nleqresults(state, ref x, rep); x = new double[2]; x[0] = 20*math.randomreal()-10; x[1] = 20*math.randomreal()-10; nleq.nleqrestartfrom(state, x); while( nleq.nleqiteration(state) ) { testfunchbm(state); } nleq.nleqresults(state, ref x, rep); if( rep.terminationtype>0 ) { basicserrors = basicserrors | (double)(math.sqr(x[0]*x[0]+x[1]-11)+math.sqr(x[0]+x[1]*x[1]-7))>(double)(math.sqr(epsf)); } else { basicserrors = true; } // // Ability to work after hard restart: // * stopping condition: small F // * StpMax is so small that we need about 10000 iterations to // find solution (steps are small) // * choose random K significantly less that 9999 // * iterate for some time, then break, restart optimization // x = new double[2]; x[0] = 100; x[1] = 100; nleq.nleqcreatelm(2, 2, x, state); epsf = 1.0E-9; nleq.nleqsetcond(state, epsf, 0); nleq.nleqsetstpmax(state, 0.01); k = 1+math.randominteger(100); for(i=0; i<=k-1; i++) { if( !nleq.nleqiteration(state) ) { break; } testfunchbm(state); } x = new double[2]; x[0] = 20*math.randomreal()-10; x[1] = 20*math.randomreal()-10; nleq.nleqrestartfrom(state, x); while( nleq.nleqiteration(state) ) { testfunchbm(state); } nleq.nleqresults(state, ref x, rep); if( rep.terminationtype>0 ) { basicserrors = basicserrors | (double)(math.sqr(x[0]*x[0]+x[1]-11)+math.sqr(x[0]+x[1]*x[1]-7))>(double)(math.sqr(epsf)); } else { basicserrors = true; } } // // Basic tests // // Test with Himmelblau's function (1): // * ability to find correct result // passcount = 100; for(pass=0; pass<=passcount-1; pass++) { // // Ability to find correct result // x = new double[2]; x[0] = 20*math.randomreal()-10; x[1] = 20*math.randomreal()-10; nleq.nleqcreatelm(2, 1, x, state); epsf = 1.0E-9; nleq.nleqsetcond(state, epsf, 0); while( nleq.nleqiteration(state) ) { testfunchb1(state); } nleq.nleqresults(state, ref x, rep); if( rep.terminationtype>0 ) { basicserrors = basicserrors | (double)(math.sqr(x[0]*x[0]+x[1]-11)+math.sqr(x[0]+x[1]*x[1]-7))>(double)(epsf); } else { basicserrors = true; } } // // Basic tests // // Ability to detect situation when we can't find minimum // passcount = 100; for(pass=0; pass<=passcount-1; pass++) { x = new double[2]; x[0] = 20*math.randomreal()-10; x[1] = 20*math.randomreal()-10; nleq.nleqcreatelm(2, 3, x, state); epsf = 1.0E-9; nleq.nleqsetcond(state, epsf, 0); while( nleq.nleqiteration(state) ) { testfuncshbm(state); } nleq.nleqresults(state, ref x, rep); basicserrors = basicserrors | rep.terminationtype!=-4; } // // Test correctness of intermediate reports and final report: // * first report is starting point // * function value decreases on subsequent reports // * function value is correctly reported // * last report is final point // * NFunc and NJac are compared with values counted directly // * IterationsCount is compared with value counter directly // n = 2; x = new double[n]; xlast = new double[n]; x[0] = 20*math.randomreal()-10; x[1] = 20*math.randomreal()-10; xlast[0] = math.maxrealnumber; xlast[1] = math.maxrealnumber; nleq.nleqcreatelm(n, 2, x, state); nleq.nleqsetcond(state, 1.0E-6, 0); nleq.nleqsetxrep(state, true); firstrep = true; flast = math.maxrealnumber; nfunc = 0; njac = 0; itcnt = 0; while( nleq.nleqiteration(state) ) { if( state.xupdated ) { // // first report must be starting point // if( firstrep ) { for(i=0; i<=n-1; i++) { othererrors = othererrors | (double)(state.x[i])!=(double)(x[i]); } firstrep = false; } // // function value must decrease // othererrors = othererrors | (double)(state.f)>(double)(flast); // // check correctness of function value // v = math.sqr(state.x[0]*state.x[0]+state.x[1]-11)+math.sqr(state.x[0]+state.x[1]*state.x[1]-7); othererrors = othererrors | (double)(Math.Abs(v-state.f)/Math.Max(v, 1))>(double)(100*math.machineepsilon); // // update info and continue // for(i_=0; i_<=n-1;i_++) { xlast[i_] = state.x[i_]; } flast = state.f; itcnt = itcnt+1; continue; } if( state.needf ) { nfunc = nfunc+1; } if( state.needfij ) { nfunc = nfunc+1; njac = njac+1; } testfunchbm(state); } nleq.nleqresults(state, ref x, rep); if( rep.terminationtype>0 ) { othererrors = (othererrors | (double)(xlast[0])!=(double)(x[0])) | (double)(xlast[1])!=(double)(x[1]); v = math.sqr(x[0]*x[0]+x[1]-11)+math.sqr(x[0]+x[1]*x[1]-7); othererrors = othererrors | (double)(Math.Abs(flast-v)/Math.Max(v, 1))>(double)(100*math.machineepsilon); } else { converror = true; } othererrors = othererrors | rep.nfunc!=nfunc; othererrors = othererrors | rep.njac!=njac; othererrors = othererrors | rep.iterationscount!=itcnt-1; // // Test ability to set limit on algorithm steps // x = new double[2]; xlast = new double[2]; x[0] = 20*math.randomreal()+20; x[1] = 20*math.randomreal()+20; xlast[0] = x[0]; xlast[1] = x[1]; stpmax = 0.1+0.1*math.randomreal(); epsf = 1.0E-9; nleq.nleqcreatelm(2, 3, x, state); nleq.nleqsetstpmax(state, stpmax); nleq.nleqsetcond(state, epsf, 0); nleq.nleqsetxrep(state, true); while( nleq.nleqiteration(state) ) { if( state.needf | state.needfij ) { testfunchbm(state); } if( (state.needf | state.needfij) | state.xupdated ) { othererrors = othererrors | (double)(Math.Sqrt(math.sqr(state.x[0]-xlast[0])+math.sqr(state.x[1]-xlast[1])))>(double)(1.00001*stpmax); } if( state.xupdated ) { xlast[0] = state.x[0]; xlast[1] = state.x[1]; } } // // end // waserrors = (basicserrors | converror) | othererrors; if( !silent ) { System.Console.Write("TESTING NLEQ SOLVER"); System.Console.WriteLine(); System.Console.Write("BASIC FUNCTIONALITY: "); if( basicserrors ) { System.Console.Write("FAILED"); System.Console.WriteLine(); } else { System.Console.Write("OK"); System.Console.WriteLine(); } System.Console.Write("CONVERGENCE: "); 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; }