#include <math_Powell.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
+#include <Precision.hxx>
//=======================================================================
{
Standard_Integer i;
- // Compute initial values for myF, myY, myC.
- computeInitialValues();
-
// Compute parameters range
Standard_Real minLength = RealLast();
Standard_Real maxLength = RealFirst();
maxLength = currentLength;
}
+ if (minLength < Precision::PConfusion())
+ {
+ #ifdef OCCT_DEBUG
+ cout << "math_GlobOptMin::Perform(): Degenerated parameters space" << endl;
+ #endif
+
+ return;
+ }
+
+ // Compute initial values for myF, myY, myC.
+ computeInitialValues();
+
myE1 = minLength * myTol;
myE2 = maxLength * myTol;
if (myC > 1.0)
Standard_Integer i;
math_Vector aCurrPnt(1, myN);
math_Vector aBestPnt(1, myN);
-
+ math_Vector aParamStep(1, myN);
Standard_Real aCurrVal = RealLast();
Standard_Real aBestVal = RealLast();
mySolCount++;
// Lipschitz const approximation
- Standard_Real aLipConst = 0.0, aPrevVal;
+ Standard_Real aLipConst = 0.0, aPrevValDiag, aPrevValProj;
Standard_Integer aPntNb = 13;
- myFunc->Value(myA, aPrevVal);
+ myFunc->Value(myA, aPrevValDiag);
+ aPrevValProj = aPrevValDiag;
Standard_Real aStep = (myB - myA).Norm() / aPntNb;
+ aParamStep = (myB - myA) / aPntNb;
for(i = 1; i <= aPntNb; i++)
{
- aCurrPnt = myA + (myB - myA) * i / (aPntNb - 1);
- myFunc->Value(aCurrPnt, aCurrVal);
+ aCurrPnt = myA + aParamStep * i;
- if(Abs(aCurrVal - aPrevVal) / aStep > aLipConst)
- aLipConst = Abs(aCurrVal - aPrevVal) / aStep;
+ // Walk over diagonal.
+ myFunc->Value(aCurrPnt, aCurrVal);
+ aLipConst = Max (Abs(aCurrVal - aPrevValDiag), aLipConst);
+ aPrevValDiag = aCurrVal;
- aPrevVal = aCurrVal;
+ // Walk over diag in projected space aPnt(1) = myA(1) = const.
+ aCurrPnt(1) = myA(1);
+ myFunc->Value(aCurrPnt, aCurrVal);
+ aLipConst = Max (Abs(aCurrVal - aPrevValProj), aLipConst);
+ aPrevValProj = aCurrVal;
}
- aLipConst *= Sqrt(myN);
+
+ aLipConst *= Sqrt(myN) / aStep;
if (aLipConst < myC * 0.1)
{