C / C++ / MFC

#include "ESSolver.h"
using namespace std;

int maxIt;
int minVal;
int maxVal;

int main(){
	int function_eval = 1, nVar = 500, mu = 15, lbd = 100, rhoO = 2, rhoS = mu;
	maxIt = 1000;
	
	if( function_eval == 1){
		minVal = -32; maxVal = 32;
	}
	
	ESSolver es(nVar, mu, lbd, rhoO, rhoS);
	es.function_eval = function_eval;
	es.Init();
	es.Optimize();

	return 0;
}

#include <iostream>
#include <vector>
#include "ESSolver.h"
#include <random>
using namespace std;

ESSolver::ESSolver(int _nVar, int _mu, int _lbd, int _rhoO, int _rhoS):nVar(_nVar), mu(_mu), lbd(_lbd), rhoO(_rhoO), rhoS(_rhoS)
{	
    muPop.resize(mu);
    muSigma.resize(mu);
    muSigma2.resize(mu);
    
    for (int i = 0; i < mu; i++) {
        muPop[i].resize(nVar);
        muSigma2[i].resize(nVar);
    }
    
    lambdaPop.resize(lbd);
    lambdaSigma.resize(lbd);
    lambdaSigma2.resize(lbd);
    
    for (int i = 0; i < lbd; i++) {
        lambdaPop[i].resize(nVar);
        lambdaSigma2[i].resize(nVar);
    }
    
    mulambdaPop.resize(mu+lbd);
    mulambdaSigma.resize(mu+lbd);
    mulambdaSigma2.resize(mu+lbd);
    
    for (int i = 0; i < mu+lbd; i++) {
        mulambdaPop[i].resize(nVar);
        mulambdaSigma2[i].resize(nVar);
    }
    
    rhoPop.resize(rhoO);
    rhoSigma.resize(rhoS);
    rhoSigma2.resize(rhoS);
    
    for (int i = 0; i < rhoO; i++) {
        rhoPop[i].resize(nVar);
    }
    
    for (int i = 0; i < rhoS; i++) {
        rhoSigma2[i].resize(nVar);
    }
    
	return;
}

ESSolver::~ESSolver(void) {
    return;
}

void ESSolver::Init() {
	for (int i = 0; i < mu; i++) {
		for (int j = 0; j < nVar; j++) {
			muPop[i][j] = rand_r(minVal, maxVal);
		}
	}
	
	if (mutOp == 0) {
	    for (int i = 0; i < mu; i++) {
            muSigma[i] = rand01_r();
	    }
	}
	else {
		for (int i = 0; i < mu; i++) {
		    for (int j = 0; j < nVar; j++) {
			    muSigma2[i][j] = rand01_r();
		    }
	    }
    } 
}

void ESSolver::Optimize() {
	int it     = 0; 	
	while (it < maxIt){
		// Manipulating values of 
        // muPop, muSigma, muSigma2, 
        // lambdaPop, lambdaSigma, lambdaSigma2, 
        // mulambdaPop, mulambdaSigma, mulambdaSigma2, 
        // rhoPop, rhoSigma, rhoSigma2
        it = it + 1;
	}
}

int ESSolver::rand_r(int minVal, int maxVal) {
    default_random_engine rng( random_device{}() );
    uniform_int_distribution<int> dist( minVal, maxVal);
    return dist(rng);
}

double ESSolver::rand01_r() {
    default_random_engine rng( random_device{}() );
	uniform_real_distribution<double> dist(0.0, 1.0);
    return dist(rng);
}

#include <vector>
using namespace std;

extern int maxIt;
extern int minVal;
extern int maxVal;

class ESSolver
{
public:
	ESSolver(int, int, int, int, int);
	~ESSolver(void);
	
    void Init();
    void Optimize();
   
    int rand_r(int, int);								
    double rand01_r();
							
private:
    int nVar;
    int mu;
    int lbd;
    int rhoO;
    int rhoS;
	
	vector<vector<double>> muPop;
	vector<double> muSigma;
	vector<vector<double>> muSigma2;

	vector<vector<double>> lambdaPop;
	vector<double> lambdaSigma;
	vector<vector<double>> lambdaSigma2;

	vector<vector<double>> mulambdaPop;
	vector<double> mulambdaSigma;
	vector<vector<double>> mulambdaSigma2;

	vector<vector<double>> rhoPop;
	vector<double> rhoSigma;
	vector<vector<double>> rhoSigma2;
};