JQSakaJoo
863 lines
52 KiB
Plaintext
863 lines
52 KiB
Plaintext
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Function
|
||
{
|
||
public: //====================================================================
|
||
double CalcFunc (double &args []) //function arguments
|
||
{
|
||
int numbOfFunctions = ArraySize (args) / 2;
|
||
if (numbOfFunctions < 1) return GetMinFunValue ();
|
||
|
||
double x, y;
|
||
double sum = 0.0;
|
||
for (int i = 0; i < numbOfFunctions; i++)
|
||
{
|
||
x = args [i * 2];
|
||
y = args [i * 2 + 1];
|
||
|
||
if (!MathIsValidNumber (x)) return GetMinFunValue ();
|
||
if (!MathIsValidNumber (y)) return GetMinFunValue ();
|
||
|
||
if (x < GetMinRangeX ()) return GetMinFunValue ();
|
||
if (x > GetMaxRangeX ()) return GetMinFunValue ();
|
||
|
||
if (y < GetMinRangeY ()) return GetMinFunValue ();
|
||
if (y > GetMaxRangeY ()) return GetMinFunValue ();
|
||
|
||
//double u = -0.1;
|
||
//x = x * cos (u) - y * sin (u);
|
||
//y = x * sin (u) + y * cos (u);
|
||
|
||
sum += Core (x, y);
|
||
}
|
||
|
||
sum /= numbOfFunctions;
|
||
|
||
return sum;
|
||
}
|
||
|
||
double GetMinRangeX () { return xMinRange;}
|
||
double GetMaxRangeX () { return xMaxRange;}
|
||
|
||
double GetMinRangeY () { return yMinRange;}
|
||
double GetMaxRangeY () { return yMaxRange; }
|
||
|
||
double GetMinFuncX () { return xGlobalMin;}
|
||
double GetMaxFuncX () { return xGlobalMax;}
|
||
|
||
double GetMinFuncY () { return yGlobalMin;}
|
||
double GetMaxFuncY () { return yGlobalMax;}
|
||
|
||
double GetMinFunValue () { return globalMinFunValue;}
|
||
double GetMaxFunValue () { return globalMaxFunValue;}
|
||
string GetFuncName () { return fuName;}
|
||
|
||
virtual double Core (double x, double y)
|
||
{
|
||
return 0.0;
|
||
}
|
||
virtual double Core (double &x [])
|
||
{
|
||
return 0.0;
|
||
}
|
||
|
||
double xMinRange;
|
||
double xMaxRange;
|
||
double yMinRange;
|
||
double yMaxRange;
|
||
|
||
double xGlobalMax;
|
||
double yGlobalMax;
|
||
double xGlobalMin;
|
||
double yGlobalMin;
|
||
|
||
double globalMinFunValue;
|
||
double globalMaxFunValue;
|
||
string fuName;
|
||
|
||
public:
|
||
double Scale (double In, double InMIN, double InMAX, double OutMIN, double OutMAX)
|
||
{
|
||
if (OutMIN == OutMAX) return (OutMIN);
|
||
if (InMIN == InMAX) return ((OutMIN + OutMAX) / 2.0);
|
||
else
|
||
{
|
||
if (In < InMIN) return (OutMIN);
|
||
if (In > InMAX) return (OutMAX);
|
||
return (((In - InMIN) * (OutMAX - OutMIN) / (InMAX - InMIN)) + OutMIN);
|
||
}
|
||
}
|
||
|
||
double SeInDiSp (double In, double InMin, double InMax, double Step)
|
||
{
|
||
return (InMin + Step * (double)MathRound ((In - InMin) / Step));
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
enum EFunc
|
||
{
|
||
NONE_Func,
|
||
Skin,
|
||
SkinDiscrete,
|
||
Hilly,
|
||
HillyDiscrete,
|
||
Peaks,
|
||
Paraboloid,
|
||
Rastrigin,
|
||
Forest,
|
||
Megacity,
|
||
Universe,
|
||
Ackley,
|
||
GoldsteinPrice,
|
||
Shaffer,
|
||
Griewank,
|
||
Rosenbrock
|
||
};
|
||
|
||
C_Function *SelectFunction (EFunc f)
|
||
{
|
||
C_Function *func;
|
||
switch (f)
|
||
{
|
||
case Skin:
|
||
func = new C_Skin ();
|
||
return (GetPointer (func));
|
||
case SkinDiscrete:
|
||
func = new C_SkinDiscrete ();
|
||
return (GetPointer (func));
|
||
case Hilly:
|
||
func = new C_Hilly ();
|
||
return (GetPointer (func));
|
||
case HillyDiscrete:
|
||
func = new C_HillyDiscrete ();
|
||
return (GetPointer (func));
|
||
case Peaks:
|
||
func = new C_Peaks ();
|
||
return (GetPointer (func));
|
||
case Paraboloid:
|
||
func = new C_Paraboloid ();
|
||
return (GetPointer (func));
|
||
case Rastrigin:
|
||
func = new C_Rastrigin ();
|
||
return (GetPointer (func));
|
||
case Forest:
|
||
func = new C_Forest ();
|
||
return (GetPointer (func));
|
||
case Megacity:
|
||
func = new C_Megacity ();
|
||
return (GetPointer (func));
|
||
case Universe:
|
||
func = new C_Universe ();
|
||
return (GetPointer (func));
|
||
case Ackley:
|
||
func = new C_Ackley ();
|
||
return (GetPointer (func));
|
||
case GoldsteinPrice:
|
||
func = new C_GoldsteinPrice ();
|
||
return (GetPointer (func));
|
||
case Shaffer:
|
||
func = new C_Shaffer ();
|
||
return (GetPointer (func));
|
||
case Griewank:
|
||
func = new C_Griewank ();
|
||
return (GetPointer (func));
|
||
case Rosenbrock:
|
||
func = new C_Rosenbrock ();
|
||
return (GetPointer (func));
|
||
|
||
default:
|
||
func = NULL; return NULL;
|
||
}
|
||
}
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Skin : public C_Function
|
||
{
|
||
public: //====================================================================
|
||
C_Skin ()
|
||
{
|
||
fuName = "Skin";
|
||
|
||
//границы функции
|
||
xMinRange = -6; xMaxRange = 6;
|
||
yMinRange = -6; yMaxRange = 6;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1.0; //14.060606995534872
|
||
xGlobalMax = -3.315699080744071;
|
||
yGlobalMax = -3.0724849592478254;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0; //-4.313787122075561
|
||
xGlobalMin = 3.070541082164328;
|
||
yGlobalMin = 2.8028056112224458;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double a1 = 2 * x * x;
|
||
double a2 = 2 * y * y;
|
||
double b1 = MathCos (a1) - 1.1;
|
||
b1 = b1 * b1;
|
||
double c1 = MathSin (0.5 * x) - 1.2;
|
||
c1 = c1 * c1;
|
||
double d1 = MathCos (a2) - 1.1;
|
||
d1 = d1 * d1;
|
||
double e1 = MathSin (0.5 * y) - 1.2;
|
||
e1 = e1 * e1;
|
||
|
||
double res = b1 + c1 - d1 + e1;
|
||
|
||
return Scale (res, -4.313787122075561, 14.060606995534872, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_SkinDiscrete : public C_Function
|
||
{
|
||
public: //====================================================================
|
||
C_SkinDiscrete ()
|
||
{
|
||
fuName = "Skin Discrete";
|
||
|
||
//границы функции
|
||
xMinRange = f.GetMinRangeX (); xMaxRange = f.GetMaxRangeX ();
|
||
yMinRange = f.GetMinRangeY (); yMaxRange = f.GetMaxRangeY ();
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = f.GetMaxFunValue ();
|
||
xGlobalMax = f.GetMaxFuncX ();
|
||
yGlobalMax = f.GetMaxFuncY ();
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = f.GetMinFunValue ();
|
||
xGlobalMin = f.GetMinFuncX ();
|
||
yGlobalMin = f.GetMinFuncY ();
|
||
}
|
||
|
||
C_Skin f;
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double res = f.Core (x, y);
|
||
return SeInDiSp (res, f.GetMinFunValue (), f.GetMaxFunValue (), 0.2);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Hilly : public C_Function
|
||
{
|
||
public: //====================================================================
|
||
C_Hilly ()
|
||
{
|
||
fuName = "Hilly";
|
||
|
||
//границы функции
|
||
xMinRange = -3; xMaxRange = 3;
|
||
yMinRange = -3; yMaxRange = 3;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1; //229.91931214214105
|
||
xGlobalMax = -1.4809053654574758;
|
||
yGlobalMax = 0.6254111843389699;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0; //-39.701816104859866
|
||
xGlobalMin = 1.3200361419666748;
|
||
yGlobalMin = 1.9993728393766546;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double res = 20.0 + x * x + y * y - 10.0 * cos (2.0 * M_PI * x) - 10.0 * cos (2.0 * M_PI * y)
|
||
- 30.0 * exp (-(pow (x - 1.0, 2) + y * y) / 0.1)
|
||
+ 200.0 * exp (-(pow (x + M_PI * 0.47, 2) + pow (y - M_PI * 0.2, 2)) / 0.1) //global max
|
||
+ 100.0 * exp (-(pow (x - 0.5, 2) + pow (y + 0.5, 2)) / 0.01)
|
||
- 60.0 * exp (-(pow (x - 1.33, 2) + pow (y - 2.0, 2)) / 0.02) //global min
|
||
- 40.0 * exp (-(pow (x + 1.3, 2) + pow (y + 0.2, 2)) / 0.5)
|
||
+ 60.0 * exp (-(pow (x - 1.5, 2) + pow (y + 1.5, 2)) / 0.1);
|
||
|
||
return Scale (res, -39.701816104859866, 229.91931214214105, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_HillyDiscrete : public C_Function
|
||
{
|
||
public: //====================================================================
|
||
C_HillyDiscrete ()
|
||
{
|
||
fuName = "Hilly Discrete";
|
||
|
||
//границы функции
|
||
xMinRange = f.GetMinRangeX (); xMaxRange = f.GetMaxRangeX ();
|
||
yMinRange = f.GetMinRangeY (); yMaxRange = f.GetMaxRangeY ();
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = f.GetMaxFunValue ();
|
||
xGlobalMax = f.GetMaxFuncX ();
|
||
yGlobalMax = f.GetMaxFuncY ();
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = f.GetMinFunValue ();
|
||
xGlobalMin = f.GetMinFuncX ();
|
||
yGlobalMin = f.GetMinFuncY ();
|
||
}
|
||
|
||
C_Hilly f;
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double res = f.Core (x, y);
|
||
return SeInDiSp (res, f.GetMinFunValue (), f.GetMaxFunValue (), 0.05);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Peaks : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Peaks ()
|
||
{
|
||
fuName = "Peaks";
|
||
|
||
//границы функции
|
||
xMinRange = -10; xMaxRange = 10;
|
||
yMinRange = -10; yMaxRange = 10;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1.0; //33.252940767815666
|
||
xGlobalMax = 3.6172118548423646;
|
||
yGlobalMax = 4.911783359236607;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0; //-4.1530660577390766
|
||
xGlobalMin = 2.3467375713370155;
|
||
yGlobalMin = 5.6567339091158795;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double k = 0.0;
|
||
double X = 3.0 - x;
|
||
double Y = 4.0 - y;
|
||
|
||
if (x >= 0.0 && y >= 0.0)
|
||
{
|
||
k = 20.0;
|
||
}
|
||
|
||
double res = k * MathPow ((1 - X), 2) * MathExp (-X * X - (Y + 1) * (Y + 1)) - 10 * (0.2 * X - MathPow (X, 3) - MathPow (Y, 5)) * MathExp (-X * X - Y * Y) - 1 / 3 * MathExp (-(X + 1) * (X + 1) - Y * Y);
|
||
|
||
return Scale (res, -4.1530660577390766, 33.252940767815666, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
// Paraboloid, F(Xn) ∈ [0.0; 1.0], X ∈ [-10.0; 10.0], maximization
|
||
class C_Paraboloid : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Paraboloid ()
|
||
{
|
||
fuName = "Paraboloid";
|
||
|
||
//границы функции
|
||
xMinRange = -10; xMaxRange = 10;
|
||
yMinRange = -10; yMaxRange = 10;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1;
|
||
xGlobalMax = 0.0;
|
||
yGlobalMax = 0.0;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0;
|
||
xGlobalMin = 10;
|
||
yGlobalMin = 10;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
return ((-x * x + 100.0) * 0.01 + (-y * y + 100.0) * 0.01) * 0.5;
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Rastrigin : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Rastrigin ()
|
||
{
|
||
fuName = "Rastrigin";
|
||
|
||
//границы функции
|
||
xMinRange = -5; xMaxRange = 5;
|
||
yMinRange = -5; yMaxRange = 5;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1.0; //80.70658038767792
|
||
xGlobalMax = 4.522993657149848;
|
||
yGlobalMax = 4.522993657149848;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0; //1.2390563437933917e-14
|
||
xGlobalMin = 0.0;
|
||
yGlobalMin = 0.0;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double res = 20.0 + x * x + y * y
|
||
- 10.0 * cos (2.0 * M_PI * x)
|
||
- 10.0 * cos (2.0 * M_PI * y);
|
||
|
||
//return Scale (res, 1.2390563437933917e-14, 80.70658038767792, 0.0, 1.0);
|
||
return Scale (-res, -80.70658038767792, -1.2390563437933917e-14, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Forest : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Forest ()
|
||
{
|
||
fuName = "Forest";
|
||
|
||
//границы функции
|
||
xMinRange = -42.50; xMaxRange = -37;
|
||
yMinRange = -45; yMaxRange = -39.8;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1.0; // raw: 3.0269632693877031
|
||
xGlobalMax = -37.6991104999996764;
|
||
yGlobalMax = -41.9822944000032692;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0; // raw: 0.0000000000000000
|
||
xGlobalMin = -39.0288234999996675;
|
||
yGlobalMin = -39.9586780000031325;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double a = MathSin (MathSqrt (MathAbs (x - 1.13) + MathAbs (y - 2.0)));
|
||
double b = MathCos (MathSqrt (MathAbs (MathSin (x))) + MathSqrt (MathAbs (MathSin (y - 2.0))));
|
||
double f = a + b
|
||
+ 1.01 * exp (-(pow (x + 42, 2) + pow (y + 43.5, 2)) / 0.9)
|
||
+ 1.0 * exp (-(pow (x + 40.2, 2) + pow (y + 46, 2)) / 0.3);
|
||
|
||
double res = MathPow (f, 4)
|
||
- 0.3 * exp (-(pow (x + 42.3, 2) + pow (y + 46.0, 2)) / 0.02);
|
||
|
||
//return res;
|
||
return Scale (res, 0.0000000000000000, 3.0269632693877031, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Megacity : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Megacity ()
|
||
{
|
||
fuName = "Megacity";
|
||
|
||
//границы функции
|
||
xMinRange = -10.0; xMaxRange = -2;
|
||
yMinRange = -10.5; yMaxRange = 10;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1.0; //12.0
|
||
xGlobalMax = -9.428;//-9.60528;
|
||
yGlobalMax = 2.0009;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0; //-1
|
||
xGlobalMin = -10.0;
|
||
yGlobalMin = -7.66485;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double a = MathSin (MathSqrt (MathAbs (x + 10.13) + MathAbs (y - 5.0)));
|
||
double b = MathCos (MathSqrt (MathAbs (MathSin (x))) + MathSqrt (MathAbs (MathSin (y - 2.0))));
|
||
double f = a + b;
|
||
|
||
double res = floor (MathPow (f, 4)) -
|
||
floor (2 * exp (-(pow (x + 9.5, 2) + pow (y + 7.5, 2)) / 0.4));
|
||
|
||
if (res < -1.0) res = -1.0;
|
||
|
||
return Scale (res, -1.0, 14.0, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Ackley : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Ackley ()
|
||
{
|
||
fuName = "Ackley";
|
||
|
||
//границы функции
|
||
xMinRange = -5; xMaxRange = 5;
|
||
yMinRange = -5; yMaxRange = 5;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1.0; //0.0;
|
||
xGlobalMax = 0.0;
|
||
yGlobalMax = 0.0;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0; //-14.302667500265278;
|
||
xGlobalMin = -4.597534757757757;
|
||
yGlobalMin = 4.597534757757757;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double res1 = -20.0 * MathExp (-0.2 * MathSqrt (0.5 * (x * x + y * y)));
|
||
double res2 = -MathExp (0.5 * (MathCos (2.0 * M_PI * x) + MathCos (2.0 * M_PI * y)));
|
||
double res3 = -(res1 + res2 + M_E + 20.0);
|
||
|
||
return Scale (res3, -14.302667500265278, 0.0, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_GoldsteinPrice : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_GoldsteinPrice ()
|
||
{
|
||
fuName = "GoldsteinPrice";
|
||
|
||
//границы функции
|
||
xMinRange = -2; xMaxRange = 2;
|
||
yMinRange = -2; yMaxRange = 2;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1.0; //-3;
|
||
xGlobalMax = 0;
|
||
yGlobalMax = -1;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0; //-1015690.2717980597;
|
||
xGlobalMin = -1.7373725379666005;
|
||
yGlobalMin = 2;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double part1 = 1 + MathPow ((x + y + 1), 2) * (19 - 14 * x + 3 * x * x - 14 * y + 6 * x * y + 3 * y * y);
|
||
double part2 = 30 + MathPow ((2 * x - 3 * y), 2) * (18 - 32 * x + 12 * x * x + 48 * y - 36 * x * y + 27 * y * y);
|
||
|
||
return Scale (-part1 * part2, -1015690.2717980597, -3.0, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
// Минимум функции Шаффера N2 достигается при (x = 0) и (y = 0),
|
||
// значение функции в этой точке равно 0.
|
||
class C_Shaffer : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Shaffer ()
|
||
{
|
||
fuName = "Shaffer";
|
||
|
||
//границы функции
|
||
xMinRange = -100;
|
||
xMaxRange = 100;
|
||
yMinRange = -100;
|
||
yMaxRange = 100;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 1.0; //0.0;
|
||
xGlobalMax = 0.0;
|
||
yGlobalMax = 0.0;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0; //-0.9984331449753265
|
||
xGlobalMin = 1.253115070280703;
|
||
yGlobalMin = 0.0;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double numerator = MathPow (MathSin (x * x - y * y), 2) - 0.5;
|
||
double denominator = MathPow (1 + 0.001 * (x * x + y * y), 2);
|
||
|
||
return Scale (-(0.5 + numerator / denominator), -0.9984331449753265, 0, 0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Universe : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Universe ()
|
||
{
|
||
fuName = "Universe";
|
||
|
||
//границы функции
|
||
xMinRange = -100; xMaxRange = 100;
|
||
yMinRange = -100; yMaxRange = 100;
|
||
|
||
//координаты максимума
|
||
globalMaxFunValue = 0.0;
|
||
xGlobalMax = 0.0;
|
||
yGlobalMax = 0.0;
|
||
|
||
//координаты минимума
|
||
globalMinFunValue = 0.0;
|
||
xGlobalMin = 0.0;
|
||
yGlobalMin = 0.0;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
return (0.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
// Функция Гривана (Griewank)
|
||
//
|
||
// Источник: Griewank A.O. "Generalized descent for global optimization"
|
||
// Journal of Optimization Theory and Applications, 34(1), 1980, pp. 11-39.
|
||
// Тестовая карточка: https://www.sfu.ca/~ssurjano/griewank.html
|
||
//
|
||
// Формула:
|
||
// f(x, y) = (x² + y²) / 4000 − cos(x) · cos(y/√2) + 1
|
||
//
|
||
// Глобальный минимум: f(0, 0) = 0 → в фреймворке максимизации: Scale = 1.0
|
||
// Максимум raw ≈ 2.141 вблизи (−15.716, −17.798) → Scale = 0.0
|
||
//
|
||
// Область поиска: x, y ∈ [−20, 20]
|
||
// Диапазон выбран так, чтобы косинусная рябь была визуально различима:
|
||
// при [-600,600] период cos (~2π≈6.28) составляет <1% ширины экрана и
|
||
// сливается в однородную текстуру, неотличимую от параболоида.
|
||
// При [-20,20] на картинку попадает ~6 периодов по X и ~4.5 по Y,
|
||
// и характерные кольца чётко видны на 2D-визуализации.
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Griewank : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Griewank ()
|
||
{
|
||
fuName = "Griewank";
|
||
|
||
//границы функции
|
||
xMinRange = -20.0; xMaxRange = 20.0;
|
||
yMinRange = -20.0; yMaxRange = 20.0;
|
||
|
||
//координаты максимума (фреймворк: минимум исходной функции)
|
||
globalMaxFunValue = 1.0;
|
||
xGlobalMax = 0.0;
|
||
yGlobalMax = 0.0;
|
||
|
||
//координаты минимума (фреймворк: максимум исходной функции)
|
||
globalMinFunValue = 0.0;
|
||
xGlobalMin = -15.715716;
|
||
yGlobalMin = -17.797798;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double f = (x * x + y * y) / 4000.0
|
||
- MathCos (x) * MathCos (y / MathSqrt (2.0))
|
||
+ 1.0;
|
||
|
||
return Scale (-f, -2.140734, 0.0, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
// Функция Розенброка («банановая долина», Rosenbrock)
|
||
//
|
||
// Источник: Rosenbrock H.H. "An automatic method for finding the greatest
|
||
// or least value of a function", The Computer Journal, 3(3), 1960, pp. 175-184.
|
||
// Тестовая карточка: https://www.sfu.ca/~ssurjano/rosen.html
|
||
//
|
||
// Формула:
|
||
// f(x, y) = 100·(y − x²)² + (1 − x)²
|
||
//
|
||
// Глобальный минимум: f(1, 1) = 0 → в фреймворке максимизации: Scale = 1.0
|
||
// Максимум raw ≈ 3905.926 в углу (−2.048, −2.048) → Scale = 0.0
|
||
// Область поиска: x, y ∈ [−2.048, 2.048]
|
||
//
|
||
// Классический тест на преодоление узкой параболической долины.
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Rosenbrock : public C_Function
|
||
{
|
||
public: //===================================================================
|
||
C_Rosenbrock ()
|
||
{
|
||
fuName = "Rosenbrock";
|
||
|
||
//границы функции
|
||
xMinRange = -2.048; xMaxRange = 2.048;
|
||
yMinRange = -2.048; yMaxRange = 2.048;
|
||
|
||
//координаты максимума (фреймворк: минимум исходной функции)
|
||
globalMaxFunValue = 1.0;
|
||
xGlobalMax = 1.0;
|
||
yGlobalMax = 1.0;
|
||
|
||
//координаты минимума (фреймворк: максимум исходной функции)
|
||
globalMinFunValue = 0.0;
|
||
xGlobalMin = -2.048;
|
||
yGlobalMin = -2.048;
|
||
}
|
||
|
||
double Core (double x, double y)
|
||
{
|
||
double f = 100.0 * MathPow (y - x * x, 2) + MathPow (1.0 - x, 2);
|
||
|
||
return Scale (-f, -3905.926227, 0.0, 0.0, 1.0);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
// GenerateFunctionDataFixedSize
|
||
bool GenerateFunctionDataFixedSize (int x_size, int y_size, double &data [], double x_min, double x_max, double y_min, double y_max, C_Function &function)
|
||
{
|
||
if (x_size < 2 || y_size < 2)
|
||
{
|
||
PrintFormat ("Error in data sizes: x_size=%d,y_size=%d", x_size, y_size);
|
||
return (false);
|
||
}
|
||
|
||
double dx = (x_max - x_min) / (x_size - 1);
|
||
double dy = (y_max - y_min) / (y_size - 1);
|
||
|
||
ArrayResize (data, x_size * y_size);
|
||
|
||
//---
|
||
for (int j = 0; j < y_size; j++)
|
||
{
|
||
for (int i = 0; i < x_size; i++)
|
||
{
|
||
double x = x_min + i * dx;
|
||
double y = y_min + j * dy;
|
||
|
||
data [j * x_size + i] = function.Core (x, y);
|
||
}
|
||
}
|
||
return (true);
|
||
}
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
// GenerateDataFixedSize
|
||
bool GenerateDataFixedSize (int x_size, int y_size, C_Function &function, double &data [])
|
||
{
|
||
if (x_size < 2 || y_size < 2)
|
||
{
|
||
PrintFormat ("Error in data sizes: x_size=%d,y_size=%d", x_size, y_size);
|
||
return (false);
|
||
}
|
||
|
||
return GenerateFunctionDataFixedSize (x_size, y_size, data,
|
||
function.GetMinRangeX (),
|
||
function.GetMaxRangeX (),
|
||
function.GetMinRangeY (),
|
||
function.GetMaxRangeY (),
|
||
function);
|
||
}
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
|
||
/*
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
class C_Multiverse
|
||
{
|
||
public: //===================================================================
|
||
C_Multiverse ()
|
||
{
|
||
}
|
||
|
||
C_Hilly H;
|
||
C_Forest F;
|
||
C_Megacity M;
|
||
|
||
string GetFuncName ()
|
||
{
|
||
return ("Multiverse:" + H.GetFuncName () + ":" + F.GetFuncName () + ":" + M.GetFuncName ());
|
||
}
|
||
|
||
double hArg [2];
|
||
double fArg [2];
|
||
double mArg [2];
|
||
|
||
void GetFuncRanges (double &rangeMin [],
|
||
double &rangeMax [],
|
||
int amount) //amount of runs functions, the number is a multiple of 6
|
||
{
|
||
ArrayResize (rangeMin, amount * 6);
|
||
ArrayResize (rangeMax, amount * 6);
|
||
|
||
for (int i = 0; i < amount; i++)
|
||
{
|
||
rangeMin [i * 6] = H.GetMinRangeX ();
|
||
rangeMin [i * 6 + 1] = F.GetMinRangeY ();
|
||
rangeMin [i * 6 + 2] = M.GetMinRangeX ();
|
||
rangeMin [i * 6 + 3] = H.GetMinRangeY ();
|
||
rangeMin [i * 6 + 4] = F.GetMinRangeX ();
|
||
rangeMin [i * 6 + 5] = M.GetMinRangeY ();
|
||
|
||
rangeMax [i * 6] = H.GetMaxRangeX ();
|
||
rangeMax [i * 6 + 1] = F.GetMaxRangeY ();
|
||
rangeMax [i * 6 + 2] = M.GetMaxRangeX ();
|
||
rangeMax [i * 6 + 3] = H.GetMaxRangeY ();
|
||
rangeMax [i * 6 + 4] = F.GetMaxRangeX ();
|
||
rangeMax [i * 6 + 5] = M.GetMaxRangeY ();
|
||
}
|
||
}
|
||
|
||
double CalcFunc (double &args [], //function arguments
|
||
int amount) //amount of runs functions
|
||
{
|
||
double result = 0.0;
|
||
|
||
for (int i = 0; i < amount; i++)
|
||
{
|
||
hArg [0] = args [i * 6];
|
||
hArg [1] = args [i * 6 + 3];
|
||
|
||
fArg [0] = args [i * 6 + 1];
|
||
fArg [1] = args [i * 6 + 4];
|
||
|
||
mArg [0] = args [i * 6 + 2];
|
||
mArg [1] = args [i * 6 + 5];
|
||
|
||
result+= H.CalcFunc (hArg, 1);
|
||
result+= F.CalcFunc (fArg, 1);
|
||
result+= M.CalcFunc (mArg, 1);
|
||
}
|
||
|
||
return result / (3.0 * amount);
|
||
}
|
||
};
|
||
//——————————————————————————————————————————————————————————————————————————————
|
||
*/ |