/// <summary> /// Find the best common gamma. Use the same gamma for all kernels. This is a /// crude brute-force search. The range found should be refined using the /// "Brent Method", also provided in this class. /// </summary> /// /// <param name="low">The low gamma to begin the search with.</param> /// <param name="high">The high gamma to end the search with.</param> /// <param name="numberOfPoints">If you do set this to negative, set x2 and y2 to the correct values.</param> /// <param name="useLog">Should we progress "logarithmically" from low to high.</param> /// <param name="minError">We are done if the error is below this.</param> /// <param name="network">The network to evaluate.</param> public void FindBestRange(double low, double high, int numberOfPoints, bool useLog, double minError, ICalculationCriteria network) { int i, ibest; double x, y, rate, previous; bool firstPointKnown; // if the number of points is negative, then // we already know the first point. Don't recalculate it. if (numberOfPoints < 0) { numberOfPoints = -numberOfPoints; firstPointKnown = true; } else { firstPointKnown = false; } // Set the rate to go from high to low. We are either advancing // logarithmically, or linear. if (useLog) { rate = Math.Exp(Math.Log(high/low)/(numberOfPoints - 1)); } else { rate = (high - low)/(numberOfPoints - 1); } // Start the search at the low. x = low; previous = 0.0d; ibest = -1; // keep track of if the error is getting worse. bool gettingWorse = false; // Try the specified number of points, between high and low. for (i = 0; i < numberOfPoints; i++) { // Determine the error. If the first point is known, then us y2 as // the error. if ((i > 0) || !firstPointKnown) { y = network.CalcErrorWithSingleSigma(x); } else { y = _y2; } // Have we found a new best candidate point? if ((i == 0) || (y < _y2)) { // yes, we found a new candidate point! ibest = i; _x2 = x; _y2 = y; _y1 = previous; // Function value to its left gettingWorse = false; // Flag that min is not yet bounded } else if (i == (ibest + 1)) { // Things are getting worse! // Might be the right neighbor of the best found. _y3 = y; gettingWorse = true; } // Track the left neighbour of the best. previous = y; // Is this good enough? Might be able to stop early if ((_y2 <= minError) && (ibest > 0) && gettingWorse) { break; } // Decrease the rate either linearly or if (useLog) { x *= rate; } else { x += rate; } } /* * At this point we have a minimum (within low,high) at (x2,y2). Compute * x1 and x3, its neighbors. We already know y1 and y3 (unless the * minimum is at an endpoint!). */ // We have now located a minimum! Yeah!! // Lets calculate the neighbors. x1 and x3, which are the sigmas. // We should already have y1 and y3 calculated, these are the errors, // and are expensive to recalculate. if (useLog) { _x1 = _x2/rate; _x3 = _x2*rate; } else { _x1 = _x2 - rate; _x3 = _x2 + rate; } // We are really done at this point. But for "extra credit", we check to // see if things were "getting worse". // // If NOT, and things were getting better, the user probably cropped the // gamma range a bit short. After all, it is hard to guess at a good // gamma range. // // To try and get the best common gamma that we can, we will actually // slip off the right-hand high-range and search for an even better // gamma. if (!gettingWorse) { // Search as far as needed! (endless loop) for (;;) { // calculate at y3(the end point) _y3 = network.CalcErrorWithSingleSigma(_x3); // If we are not finding anything better, then stop! // We are already outside the specified search range. if (_y3 > _y2) { break; } if ((_y1 == _y2) && (_y2 == _y3)) { break; } // Shift the points for the new range, as we have // extended to the right. _x1 = _x2; _y1 = _y2; _x2 = _x3; _y2 = _y3; // We want to step further each time. We can't search forever, // and we are already outside of the area we were supposed to // scan. rate *= 3.0d; if (useLog) { _x3 *= rate; } else { _x3 += rate; } } } // We will also handle one more "bad situation", which results from a // bad gamma search range. // // What if the first gamma was tried, and that was the best it ever got? // // If this is the case, there MIGHT be better gammas to the left of the // search space. Lets try those. else if (ibest == 0) { // Search as far as needed! (endless loop) for (;;) { // Calculate at y3(the begin point) _y1 = network.CalcErrorWithSingleSigma(_x1); if (_y1 < 0.0d) { return; } // If we are not finding anything better, then stop! // We are already outside the specified search range. if (_y1 > _y2) { break; } if ((_y1 == _y2) && (_y2 == _y3)) { break; } // Shift the points for the new range, as we have // extended to the left. _x3 = _x2; _y3 = _y2; _x2 = _x1; _y2 = _y1; // We want to step further each time. We can't search forever, // and we are already outside of the area we were supposed to // scan. rate *= 3.0d; if (useLog) { _x1 /= rate; } else { _x1 -= rate; } } } return; }
/// <summary> /// Use the "Brent Method" to find a better minimum. /// </summary> /// /// <param name="maxIterations">THe maximum number of iterations.</param> /// <param name="maxError">We can stop if we reach this error.</param> /// <param name="eps">The approximate machine precision.</param> /// <param name="tol">Brent's tolerance, must be >= sqrt( eps )</param> /// <param name="network">The network to obtain the error from.</param> /// <param name="y">The error at x2.</param> /// <returns>The best error.</returns> public double Brentmin(int maxIterations, double maxError, double eps, double tol, ICalculationCriteria network, double y) { double prevdist = 0.0d; double step = 0.0d; // xBest is the minimum function ordinate thus far. // also keep 2nd and 3rd double xbest = _x2; double x2ndBest = _x2; double x3rdBest = _x2; // Keep the minimum bracketed between xlow and xhigh. // Get the low and high from our previous "crude" search. double xlow = _x1; double xhigh = _x3; double fbest = y; double fsecbest = y; double fthirdbest = y; // Main loop. // We will go up to the specified number of iterations. // Hopefully we will "break out" long before that happens! for (int iter = 0; iter < maxIterations; iter++) { // Have we reached an acceptable error? if (fbest < maxError) { break; } double xmid = 0.5d*(xlow + xhigh); double tol1 = tol*(Math.Abs(xbest) + eps); double tol2 = 2.0*tol1; // See if xlow is close relative to tol2, // Also, that that xbest is near the midpoint. if (Math.Abs(xbest - xmid) <= (tol2 - 0.5d*(xhigh - xlow))) { break; } // Don't go to close to eps, the machine precision. if ((iter >= 2) && ((fthirdbest - fbest) < eps)) { break; } double xrecent = 0; // Try parabolic fit, if we moved far enough. if (Math.Abs(prevdist) > tol1) { // Temps holders for the parabolic estimate double t1 = (xbest - x2ndBest)*(fbest - fthirdbest); double t2 = (xbest - x3rdBest)*(fbest - fsecbest); double numer = (xbest - x3rdBest)*t2 - (xbest - x2ndBest)*t1; double denom = 2.0*(t1 - t2); double testdist = prevdist; prevdist = step; // This is the parabolic estimate to min. if (denom != 0.0d) { step = numer/denom; } else { // test failed. step = 1.0e30d; } // If shrinking, and within bounds, then use the parabolic // estimate. if ((Math.Abs(step) < Math.Abs(0.5d*testdist)) && (step + xbest > xlow) && (step + xbest < xhigh)) { xrecent = xbest + step; // If very close to known bounds. if ((xrecent - xlow < tol2) || (xhigh - xrecent < tol2)) { if (xbest < xmid) { step = tol1; } else { step = -tol1; } } } else { // Parabolic estimate poor, so use golden section prevdist = (xbest >= xmid) ? xlow - xbest : xhigh - xbest; step = Cgold*prevdist; } } else { // prevdist did not exceed tol1: we did not move far // enough // to justify a parabolic fit. Use golden section. prevdist = (xbest >= xmid) ? xlow - xbest : xhigh - xbest; step = .3819660d*prevdist; } if (Math.Abs(step) >= tol1) { xrecent = xbest + step; // another trial we must move a } else { // decent distance. if (step > 0.0) { xrecent = xbest + tol1; } else { xrecent = xbest - tol1; } } /* * At long last we have a trial point 'xrecent'. Evaluate the * function. */ double frecent = network.CalcErrorWithSingleSigma(xrecent); if (frecent < 0.0d) { break; } if (frecent <= fbest) { // If we improved... if (xrecent >= xbest) { xlow = xbest; // replacing the appropriate endpoint } else { xhigh = xbest; } x3rdBest = x2ndBest; // Update x and f values for best, x2ndBest = xbest; // second and third best xbest = xrecent; fthirdbest = fsecbest; fsecbest = fbest; fbest = frecent; } else { // We did not improve if (xrecent < xbest) { xlow = xrecent; // replacing the appropriate endpoint } else { xhigh = xrecent; } if ((frecent <= fsecbest) || (x2ndBest == xbest)) { x3rdBest = x2ndBest; x2ndBest = xrecent; fthirdbest = fsecbest; fsecbest = frecent; } else if ((frecent <= fthirdbest) || (x3rdBest == xbest) || (x3rdBest == x2ndBest)) { x3rdBest = xrecent; fthirdbest = frecent; } } } // update the three sigmas. _x1 = xlow; _x2 = xbest; _x3 = xhigh; // return the best. return fbest; }
/// <summary> /// Use the "Brent Method" to find a better minimum. /// </summary> /// /// <param name="maxIterations">THe maximum number of iterations.</param> /// <param name="maxError">We can stop if we reach this error.</param> /// <param name="eps">The approximate machine precision.</param> /// <param name="tol">Brent's tolerance, must be >= sqrt( eps )</param> /// <param name="network">The network to obtain the error from.</param> /// <param name="y">The error at x2.</param> /// <returns>The best error.</returns> public double Brentmin(int maxIterations, double maxError, double eps, double tol, ICalculationCriteria network, double y) { double prevdist = 0.0d; double step = 0.0d; // xBest is the minimum function ordinate thus far. // also keep 2nd and 3rd double xbest = _x2; double x2ndBest = _x2; double x3rdBest = _x2; // Keep the minimum bracketed between xlow and xhigh. // Get the low and high from our previous "crude" search. double xlow = _x1; double xhigh = _x3; double fbest = y; double fsecbest = y; double fthirdbest = y; // Main loop. // We will go up to the specified number of iterations. // Hopefully we will "break out" long before that happens! for (int iter = 0; iter < maxIterations; iter++) { // Have we reached an acceptable error? if (fbest < maxError) { break; } double xmid = 0.5d * (xlow + xhigh); double tol1 = tol * (Math.Abs(xbest) + eps); double tol2 = 2.0 * tol1; // See if xlow is close relative to tol2, // Also, that that xbest is near the midpoint. if (Math.Abs(xbest - xmid) <= (tol2 - 0.5d * (xhigh - xlow))) { break; } // Don't go to close to eps, the machine precision. if ((iter >= 2) && ((fthirdbest - fbest) < eps)) { break; } double xrecent = 0; // Try parabolic fit, if we moved far enough. if (Math.Abs(prevdist) > tol1) { // Temps holders for the parabolic estimate double t1 = (xbest - x2ndBest) * (fbest - fthirdbest); double t2 = (xbest - x3rdBest) * (fbest - fsecbest); double numer = (xbest - x3rdBest) * t2 - (xbest - x2ndBest) * t1; double denom = 2.0 * (t1 - t2); double testdist = prevdist; prevdist = step; // This is the parabolic estimate to min. if (denom != 0.0d) { step = numer / denom; } else { // test failed. step = 1.0e30d; } // If shrinking, and within bounds, then use the parabolic // estimate. if ((Math.Abs(step) < Math.Abs(0.5d * testdist)) && (step + xbest > xlow) && (step + xbest < xhigh)) { xrecent = xbest + step; // If very close to known bounds. if ((xrecent - xlow < tol2) || (xhigh - xrecent < tol2)) { if (xbest < xmid) { step = tol1; } else { step = -tol1; } } } else { // Parabolic estimate poor, so use golden section prevdist = (xbest >= xmid) ? xlow - xbest : xhigh - xbest; step = Cgold * prevdist; } } else { // prevdist did not exceed tol1: we did not move far // enough // to justify a parabolic fit. Use golden section. prevdist = (xbest >= xmid) ? xlow - xbest : xhigh - xbest; step = .3819660d * prevdist; } if (Math.Abs(step) >= tol1) { xrecent = xbest + step; // another trial we must move a } else { // decent distance. if (step > 0.0) { xrecent = xbest + tol1; } else { xrecent = xbest - tol1; } } /* * At long last we have a trial point 'xrecent'. Evaluate the * function. */ double frecent = network.CalcErrorWithSingleSigma(xrecent); if (frecent < 0.0d) { break; } if (frecent <= fbest) { // If we improved... if (xrecent >= xbest) { xlow = xbest; // replacing the appropriate endpoint } else { xhigh = xbest; } x3rdBest = x2ndBest; // Update x and f values for best, x2ndBest = xbest; // second and third best xbest = xrecent; fthirdbest = fsecbest; fsecbest = fbest; fbest = frecent; } else { // We did not improve if (xrecent < xbest) { xlow = xrecent; // replacing the appropriate endpoint } else { xhigh = xrecent; } if ((frecent <= fsecbest) || (x2ndBest == xbest)) { x3rdBest = x2ndBest; x2ndBest = xrecent; fthirdbest = fsecbest; fsecbest = frecent; } else if ((frecent <= fthirdbest) || (x3rdBest == xbest) || (x3rdBest == x2ndBest)) { x3rdBest = xrecent; fthirdbest = frecent; } } } // update the three sigmas. _x1 = xlow; _x2 = xbest; _x3 = xhigh; // return the best. return(fbest); }
/// <summary> /// Find the best common gamma. Use the same gamma for all kernels. This is a /// crude brute-force search. The range found should be refined using the /// "Brent Method", also provided in this class. /// </summary> /// /// <param name="low">The low gamma to begin the search with.</param> /// <param name="high">The high gamma to end the search with.</param> /// <param name="numberOfPoints">If you do set this to negative, set x2 and y2 to the correct values.</param> /// <param name="useLog">Should we progress "logarithmically" from low to high.</param> /// <param name="minError">We are done if the error is below this.</param> /// <param name="network">The network to evaluate.</param> public void FindBestRange(double low, double high, int numberOfPoints, bool useLog, double minError, ICalculationCriteria network) { int i, ibest; double x, y, rate, previous; bool firstPointKnown; // if the number of points is negative, then // we already know the first point. Don't recalculate it. if (numberOfPoints < 0) { numberOfPoints = -numberOfPoints; firstPointKnown = true; } else { firstPointKnown = false; } // Set the rate to go from high to low. We are either advancing // logarithmically, or linear. if (useLog) { rate = Math.Exp(Math.Log(high / low) / (numberOfPoints - 1)); } else { rate = (high - low) / (numberOfPoints - 1); } // Start the search at the low. x = low; previous = 0.0d; ibest = -1; // keep track of if the error is getting worse. bool gettingWorse = false; // Try the specified number of points, between high and low. for (i = 0; i < numberOfPoints; i++) { // Determine the error. If the first point is known, then us y2 as // the error. if ((i > 0) || !firstPointKnown) { y = network.CalcErrorWithSingleSigma(x); } else { y = _y2; } // Have we found a new best candidate point? if ((i == 0) || (y < _y2)) { // yes, we found a new candidate point! ibest = i; _x2 = x; _y2 = y; _y1 = previous; // Function value to its left gettingWorse = false; // Flag that min is not yet bounded } else if (i == (ibest + 1)) { // Things are getting worse! // Might be the right neighbor of the best found. _y3 = y; gettingWorse = true; } // Track the left neighbour of the best. previous = y; // Is this good enough? Might be able to stop early if ((_y2 <= minError) && (ibest > 0) && gettingWorse) { break; } // Decrease the rate either linearly or if (useLog) { x *= rate; } else { x += rate; } } /* * At this point we have a minimum (within low,high) at (x2,y2). Compute * x1 and x3, its neighbors. We already know y1 and y3 (unless the * minimum is at an endpoint!). */ // We have now located a minimum! Yeah!! // Lets calculate the neighbors. x1 and x3, which are the sigmas. // We should already have y1 and y3 calculated, these are the errors, // and are expensive to recalculate. if (useLog) { _x1 = _x2 / rate; _x3 = _x2 * rate; } else { _x1 = _x2 - rate; _x3 = _x2 + rate; } // We are really done at this point. But for "extra credit", we check to // see if things were "getting worse". // // If NOT, and things were getting better, the user probably cropped the // gamma range a bit short. After all, it is hard to guess at a good // gamma range. // // To try and get the best common gamma that we can, we will actually // slip off the right-hand high-range and search for an even better // gamma. if (!gettingWorse) { // Search as far as needed! (endless loop) for (;;) { // calculate at y3(the end point) _y3 = network.CalcErrorWithSingleSigma(_x3); // If we are not finding anything better, then stop! // We are already outside the specified search range. if (_y3 > _y2) { break; } if ((_y1 == _y2) && (_y2 == _y3)) { break; } // Shift the points for the new range, as we have // extended to the right. _x1 = _x2; _y1 = _y2; _x2 = _x3; _y2 = _y3; // We want to step further each time. We can't search forever, // and we are already outside of the area we were supposed to // scan. rate *= 3.0d; if (useLog) { _x3 *= rate; } else { _x3 += rate; } } } // We will also handle one more "bad situation", which results from a // bad gamma search range. // // What if the first gamma was tried, and that was the best it ever got? // // If this is the case, there MIGHT be better gammas to the left of the // search space. Lets try those. else if (ibest == 0) { // Search as far as needed! (endless loop) for (;;) { // Calculate at y3(the begin point) _y1 = network.CalcErrorWithSingleSigma(_x1); if (_y1 < 0.0d) { return; } // If we are not finding anything better, then stop! // We are already outside the specified search range. if (_y1 > _y2) { break; } if ((_y1 == _y2) && (_y2 == _y3)) { break; } // Shift the points for the new range, as we have // extended to the left. _x3 = _x2; _y3 = _y2; _x2 = _x1; _y2 = _y1; // We want to step further each time. We can't search forever, // and we are already outside of the area we were supposed to // scan. rate *= 3.0d; if (useLog) { _x1 /= rate; } else { _x1 -= rate; } } } return; }
public void FindBestRange(double low, double high, int numberOfPoints, bool useLog, double minError, ICalculationCriteria network) { int num; int num2; double num3; double num4; double num5; double num6; bool flag; bool flag2; if (numberOfPoints >= 0) { flag = false; if (((uint) num5) < 0) { if ((((uint) high) - ((uint) num6)) < 0) { goto Label_0642; } if ((((uint) minError) - ((uint) useLog)) >= 0) { goto Label_054D; } goto Label_0574; } goto Label_0782; } if ((((uint) high) - ((uint) flag)) >= 0) { numberOfPoints = -numberOfPoints; flag = true; goto Label_0782; } if (((uint) useLog) >= 0) { goto Label_0639; } if ((((uint) flag2) & 0) == 0) { goto Label_0355; } goto Label_0094; Label_0064: if (num2 == 0) { goto Label_01F4; } if ((((uint) num3) | 0x7fffffff) == 0) { goto Label_033B; } if ((((uint) num2) - ((uint) num2)) >= 0) { if (((uint) useLog) <= uint.MaxValue) { return; } goto Label_0639; } if ((((uint) useLog) - ((uint) num6)) >= 0) { goto Label_0355; } if ((((uint) flag) - ((uint) numberOfPoints)) >= 0) { goto Label_0222; } goto Label_0191; Label_0094: num5 *= 3.0; if (useLog) { this._x6650a9a61c6142e3 /= num5; } else { this._x6650a9a61c6142e3 -= num5; } goto Label_01F4; Label_0191: if (this._xaa76c33ed453ba57 > this._x9b9be9a08b5115a8) { return; } if (((((uint) numberOfPoints) + ((uint) flag2)) <= uint.MaxValue) || (((uint) num4) <= uint.MaxValue)) { if ((this._xaa76c33ed453ba57 == this._x9b9be9a08b5115a8) && (this._x9b9be9a08b5115a8 == this._xb3a0be2328bf1529)) { return; } this._xb6acbfc039c06679 = this._xe75e43d266eef799; this._xb3a0be2328bf1529 = this._x9b9be9a08b5115a8; this._xe75e43d266eef799 = this._x6650a9a61c6142e3; this._x9b9be9a08b5115a8 = this._xaa76c33ed453ba57; if (((uint) flag) <= uint.MaxValue) { goto Label_0094; } if (((uint) high) >= 0) { goto Label_0222; } if (0x7fffffff != 0) { goto Label_02E5; } if (((uint) minError) >= 0) { goto Label_0064; } } else { goto Label_0191; } Label_01F4: this._xaa76c33ed453ba57 = network.CalcErrorWithSingleSigma(this._x6650a9a61c6142e3); if (this._xaa76c33ed453ba57 >= 0.0) { goto Label_0191; } return; Label_0222: if (!flag2) { goto Label_0305; } goto Label_0064; Label_028F: this._x6650a9a61c6142e3 = this._xe75e43d266eef799; this._xaa76c33ed453ba57 = this._x9b9be9a08b5115a8; this._xe75e43d266eef799 = this._xb6acbfc039c06679; this._x9b9be9a08b5115a8 = this._xb3a0be2328bf1529; num5 *= 3.0; if ((((uint) num6) - ((uint) low)) >= 0) { if (((uint) num3) < 0) { goto Label_047F; } if (!useLog) { this._xb6acbfc039c06679 += num5; } else { this._xb6acbfc039c06679 *= num5; } goto Label_0305; } Label_02E5: if (this._x9b9be9a08b5115a8 != this._xb3a0be2328bf1529) { if ((((uint) num6) - ((uint) num5)) > uint.MaxValue) { goto Label_0488; } goto Label_028F; } return; Label_0305: this._xb3a0be2328bf1529 = network.CalcErrorWithSingleSigma(this._xb6acbfc039c06679); if (((uint) num) >= 0) { if (this._xb3a0be2328bf1529 > this._x9b9be9a08b5115a8) { return; } } else { return; } Label_033B: if (this._xaa76c33ed453ba57 != this._x9b9be9a08b5115a8) { goto Label_028F; } goto Label_02E5; Label_0355: if (((uint) minError) > uint.MaxValue) { goto Label_054D; } Label_036A: if ((((uint) num4) + ((uint) minError)) > uint.MaxValue) { goto Label_0305; } if ((((uint) numberOfPoints) & 0) != 0) { goto Label_058C; } this._xb6acbfc039c06679 = this._xe75e43d266eef799 + num5; goto Label_0222; Label_03CC: if ((((uint) num5) & 0) != 0) { goto Label_042D; } if ((((uint) flag2) | 3) == 0) { return; } goto Label_0415; Label_03FD: if ((((uint) high) - ((uint) num5)) < 0) { goto Label_03CC; } Label_0415: this._x6650a9a61c6142e3 = this._xe75e43d266eef799 - num5; goto Label_0355; Label_042D: if (useLog) { goto Label_045F; } goto Label_03FD; Label_0440: if (num < numberOfPoints) { goto Label_06F6; } if ((((uint) num2) + ((uint) num5)) <= uint.MaxValue) { goto Label_042D; } Label_045F: this._x6650a9a61c6142e3 = this._xe75e43d266eef799 / num5; this._xb6acbfc039c06679 = this._xe75e43d266eef799 * num5; goto Label_0222; Label_047F: if (useLog) { num3 *= num5; } else { num3 += num5; } Label_0488: num++; if ((((uint) num6) | 1) == 0) { goto Label_01F4; } if ((((uint) high) & 0) == 0) { goto Label_0440; } goto Label_047F; Label_04D8: num6 = num4; if (((this._x9b9be9a08b5115a8 <= minError) && (num2 > 0)) && flag2) { goto Label_042D; } goto Label_047F; Label_054D: if (num == (num2 + 1)) { this._xb3a0be2328bf1529 = num4; flag2 = true; goto Label_04D8; } if ((((uint) num2) - ((uint) num6)) > uint.MaxValue) { goto Label_0574; } if ((((uint) num5) & 0) != 0) { if (((uint) num6) < 0) { goto Label_03CC; } goto Label_0732; } if (((uint) useLog) >= 0) { if ((((uint) flag) + ((uint) numberOfPoints)) <= uint.MaxValue) { goto Label_0661; } if ((((uint) num6) - ((uint) high)) <= uint.MaxValue) { goto Label_062D; } goto Label_05D2; } if ((((uint) useLog) & 0) != 0) { goto Label_054D; } Label_056C: if (num == 0) { if ((((uint) num6) + ((uint) flag)) < 0) { goto Label_068B; } goto Label_0639; } goto Label_058C; Label_0574: if ((((uint) numberOfPoints) + ((uint) high)) > uint.MaxValue) { goto Label_056C; } Label_058C: if (num4 < this._x9b9be9a08b5115a8) { goto Label_068B; } if (0 != 0) { goto Label_06CA; } goto Label_054D; Label_05D2: flag2 = false; if ((((uint) num2) | 0xff) == 0) { goto Label_036A; } goto Label_04D8; Label_062D: this._xaa76c33ed453ba57 = num6; goto Label_05D2; Label_0639: num2 = num; this._xe75e43d266eef799 = num3; Label_0642: this._x9b9be9a08b5115a8 = num4; if ((((uint) minError) - ((uint) flag)) <= uint.MaxValue) { goto Label_062D; } Label_0661: if ((((uint) numberOfPoints) | 0x80000000) != 0) { goto Label_04D8; } goto Label_03FD; Label_068B: if ((((uint) useLog) | 0x80000000) == 0) { goto Label_056C; } goto Label_0639; Label_06CA: num4 = network.CalcErrorWithSingleSigma(num3); goto Label_056C; Label_06F6: if (num > 0) { if ((((uint) num3) - ((uint) numberOfPoints)) <= uint.MaxValue) { goto Label_06CA; } goto Label_058C; } Label_0732: if (flag) { num4 = this._x9b9be9a08b5115a8; goto Label_056C; } if ((((uint) num4) | 15) != 0) { goto Label_06CA; } if (((uint) minError) <= uint.MaxValue) { } goto Label_06F6; Label_0782: if (useLog) { num5 = Math.Exp(Math.Log(high / low) / ((double) (numberOfPoints - 1))); } else { num5 = (high - low) / ((double) (numberOfPoints - 1)); } num3 = low; num6 = 0.0; num2 = -1; flag2 = false; num = 0; goto Label_0440; }