GlobalMinima (v1)

#include<iostream>
#include<cmath>
#include<cstdlib>
#include<ctime>

#define pi 3.14
using namespace std;

class Function {
protected:
    unsigned int n;
    unsigned int m;
    unsigned int SwitchOption;

    long double ComputeRandomValue(long double lower_bound, long double upper_bound) {
        srand(static_cast <unsigned> (time(0)));
        long double random = lower_bound + static_cast <long double> (rand()) / (static_cast <long double> (RAND_MAX / (upper_bound - lower_bound)));
        return random;
    }

    long double SphereFunction(unsigned int n, long double lower_bound, long double upper_bound){
        long double FunctionValue = 0;
        long double Temp;
        for (unsigned int i = 1; i <= n; ++i) {
            Temp = this->ComputeRandomValue(lower_bound, upper_bound);
            FunctionValue += pow(Temp, 2);
        }
        return FunctionValue;
    }

    long double RastriginFunction(unsigned int n, long double lower_bound, long double upper_bound){
        long double FunctionValue;
        long double Temp;
        for (unsigned int i = 1; i <= n; ++i) {
            Temp = this->ComputeRandomValue(lower_bound, upper_bound);
            Temp += pow(Temp, 2) - 10.0 * cos(2 * pi*Temp);
        }
        FunctionValue = 10.0*n + Temp;
        return FunctionValue;
    }

    long double MichalewicsFunction(unsigned int n, unsigned int m, long double lower_bound, long double upper_bound){
        long double Temp;
        long double FunctionResult = 0;
        for (unsigned int i = 1; i <= n; ++i) {
            Temp = this->ComputeRandomValue(lower_bound, upper_bound);
            FunctionResult += sin(Temp)*pow(sin(i*pow(Temp, 2) / pi), 2 * m);
        }
        return (-1)*FunctionResult;
    }

    long double HumpFunction(long double lower_bound, long double upper_bound){
        long double x1 = this->ComputeRandomValue(lower_bound, upper_bound);
        long double x2 = this->ComputeRandomValue(lower_bound, upper_bound);
        long double t1, t2, t3;
        t1 = 4 - 2.1*pow(x1, 2) + (pow(x1, 4) / 3) *pow(x1, 2);
        t2 = (-4 + 4 * pow(x2, 2))*pow(x2, 2);
        t3 = x1*x2;
        return (t1 + t2 + t3);
    }

public:
    void SetN(unsigned int n){
        this->n = n;
    }

    void SetM(unsigned int m){
        this->m = m;
    }

    void SetSwitchOption(unsigned int number) {
        if (number>0 && number < 5) {
            this->SwitchOption = number;
        }
        else {
            this->SwitchOption = rand() % 4 + 1;
        }
    }
};

class GlobalMinima : public Function {
private:
    long double GlobalMin = INT_MAX;
    long double LOW_B;
    long double UPP_B;
public:

    void ComputeBounds(long double lower_bound, long double upper_bound) {
        for (int i = 0; i < 6; ++i) { upper_bound = (lower_bound + upper_bound) / 2; }
        this->LOW_B = lower_bound;
        this->UPP_B = upper_bound;
    }

    void ComputeRandomGlobalMin() {
        switch (this->SwitchOption) {
        case 1: { // Sphere function
                    long double localMin=INT_MAX;
                    for (int j = 0; j < 100; ++j) {
                        long double LWB = this->LOW_B;
                        long double UPB = this->UPP_B;
                        long double FunctionValue;
                        for (unsigned int i = 0; i < 64; i++) {
                            FunctionValue = this->SphereFunction(this->n, LWB, UPB);
                            if (FunctionValue < localMin) {
                                localMin = FunctionValue;
                            }
                            long double temp = UPB;
                            UPB = UPB + (UPB - LWB);
                            LWB = temp;
                        }
                        if (localMin < this->GlobalMin) {
                            this->GlobalMin = localMin;
                        }
                    }
                    break;
        }
        case 2: { // Rastrigin function
                    long double localMin=INT_MAX;
                    for (int j = 0; j < 100; ++j) {
                        long double LWB = this->LOW_B;
                        long double UPB = this->UPP_B;
                        long double FunctionValue;
                        for (unsigned int i = 0; i < 64; i++) {
                            FunctionValue = this->RastriginFunction(this->n, LWB, UPB);
                            if (FunctionValue < localMin) {
                                localMin = FunctionValue;
                            }
                            long double temp = UPB;
                            UPB = UPB + (UPB - LWB);
                            LWB = temp;
                        }
                        if (localMin < this->GlobalMin) {
                            this->GlobalMin = localMin;
                        }
                    }
                    break;
        }
        case 3: { // Michalewics function
                    long double localMin = INT_MAX;
                    for (int j = 0; j < 100; ++j) {
                        long double LWB = this->LOW_B;
                        long double UPB = this->UPP_B;
                        long double FunctionValue;
                        for (unsigned int i = 0; i < 64; i++) {
                            FunctionValue = this->MichalewicsFunction(this->n, this->m, LWB, UPB);
                            if (FunctionValue < localMin) {
                                localMin = FunctionValue;
                            }
                            long double temp = UPB;
                            UPB = UPB + (UPB - LWB);
                            LWB = temp;
                        }
                        if (localMin < this->GlobalMin) {
                            this->GlobalMin = localMin;
                        }
                    }
                    break;
        }
        case 4: { // Camila's function
                    long double localMin = INT_MAX;
                    for (int j = 0; j < 100; ++j) {
                        long double LWB = this->LOW_B;
                        long double UPB = this->UPP_B;
                        long double FunctionValue;
                        for (unsigned int i = 0; i < 64; i++) {
                            FunctionValue = this->HumpFunction(LWB, UPB);
                            if (FunctionValue < localMin) {
                                localMin = FunctionValue;
                            }
                            long double temp = UPB;
                            UPB = UPB + (UPB - LWB);
                            LWB = temp;
                        }
                        if (localMin < this->GlobalMin) {
                            this->GlobalMin = localMin;
                        }
                    }
                    break;
        }
        default: break;
        }
    }

    long double GetGlobalMinima(){
        return this->GlobalMin;
    }
};

void main() {
    GlobalMinima MinimulGlobalAlUneiFunctii;
    MinimulGlobalAlUneiFunctii.SetN(2);
    MinimulGlobalAlUneiFunctii.SetM(10);
    MinimulGlobalAlUneiFunctii.ComputeBounds(-5.12, 5.12);
    MinimulGlobalAlUneiFunctii.SetSwitchOption(2);
    MinimulGlobalAlUneiFunctii.ComputeRandomGlobalMin();
    cout << "\nMinimul global al functiei alese este: " << MinimulGlobalAlUneiFunctii.GetGlobalMinima() << "\n";

}