std::cout <<"nº ações = "<< retornos.

size()<< std::endl << "nº meses = " << meses

<< std::endl;

// CÁLCULO DO RETORNO MÉDIO DE CADA AÇÃO

std::vector<std::vector<double>> retorno_risco(retornos.size(),
std::vector<double>(2));
for(auto i = 0; i < retornos.size(); i++) { //de ação em ação
double soma = 0;
for(auto j = 0; j < meses; j++) { // de mes em mes
soma = soma + retornos[i][j];
}
retorno_risco[i][0] = soma/meses; // guardando retorno medio na primeira coluna
std::cout <<"Ação = "<< simbolos[i] << " retorno medio = " << retorno_risco[i]
[0] << std::endl;
}

// CALCULO DA VARIANCIA DE CADA AÇÃO

for(auto i = 0; i < retornos.size(); i++) { //de ação em ação

double soma = 0;
for(auto j = 0; j < meses; j++) { // de mes em mes
soma = soma + pow(retornos[i][j] - retorno_risco[i][0],2);
}
retorno_risco[i][1] = soma/(meses-1); // guardando o variância na segunda
coluna
std::cout <<"Ação = "<< simbolos[i] << " variancia retornos = " <<
retorno_risco[i][1] << std::endl;
} // a expressão utilizada é a de cálculo da variância amostral, por isso a divisão
é por (n-1)

// OTIMIZAÇÃO DA CARTEIRA DE INVESTIMENTOS

auto net_upper_long_bound=1.0;
auto net_lower_long_bound=0.5;

auto rho = 0.5;

auto n = simbolos[0].size();

MPModelRequest model_request;

model_request.set_solver_type(MPModelRequest::SCIP_MIXED_INTEGER_PROGRAMMING);

auto model_proto = model_request.mutable_model();

model_proto->set_name("Otimização de Portifólio");
model_proto->set_maximize(true);

std::vector<MPVariableProto*> x(n);
for(auto i = 0; i < n; i++) {
x[i] = model_proto->add_variable();
x[i]->set_name(simbolos[0][i]);
x[i]->set_upper_bound(1.0);
x[i]->set_lower_bound(0);//long only
x[i]->set_objective_coefficient(retornos[0][i]); //FO: sum(return[i] *
allocation[i])
x[i]->set_is_integer(false);
}
 //FO: - rho * sum(sigma[i][j] * x[i] * x[j])
auto quad_obj = model_proto->mutable_quadratic_objective();
for(auto i = 0; i < n; i++) {
for(auto j = 0; j < n; j++) {
quad_obj->add_qvar1_index(i);
quad_obj->add_qvar2_index(j);
quad_obj->add_coefficient(-rho*covariance[i][j]);
}
}

//Constraint: net_lower_long_bound <= sum(x[i]) <= net_upper_long_bound

{ auto c = model_proto->add_constraint();
c->set_name("c");
c->set_lower_bound(net_lower_long_bound);
c->set_upper_bound(net_upper_long_bound);
for(auto i = 0; i < n; i++) {
c->add_var_index(i);
c->add_coefficient(1);
}

MPSolutionResponse solution_response;
MPSolver::SolveWithProto(model_request, &solution_response);

if (solution_response.status() == MPSOLVER_OPTIMAL)
std::cout << "Solução Ótima!" << std::endl;

std::vector<double> solution(n);
for (int i = 0; i < n; i++)
solution[i] = solution_response.variable_value(i);

double rs = std::inner_product(returns[0].begin(), returns[0].end(),

solution.begin(), 0.0);

std::cout << "Retorno = " << std::fixed << std::setprecision(4) << rs*100 << "%
(a.d.) "
<< std::fixed << std::setprecision(2) << rs * 252 * 100 << "% (a.a.)"<<
std::endl;

for (int i = 0; i < n; i++)

if (solution[i] > 0.01)
std::cout << tickers[0][i] << " = " << solution[i] << std::endl;