prova-02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estudo de Caso: Alocação de Ativos em Carteira de Investimentos\n",
    "\n",
    "Monte uma carteira de ações para o mês de Setembro/2020 baseado na Moderna Teoria de Portfolio (Markowitz, 1952), a qual estuda a melhor combinação possível dos ativos analisados e sugere uma alocação de ativos dentro de uma carteira que maximize o retorno. \n",
    "\n",
    "Considere as cotações históricas das ações que fazem parte da [Carteira Teórica do Ibovespa em 01/09/2020](http://www.b3.com.br/pt_br/market-data-e-indices/indices/indices-amplos/indice-ibovespa-ibovespa-composicao-da-carteira.htm) disponíveis em [ibovespa_desc.csv](ibovespa_desc.csv) e no diretório ibovespa.\n",
    "\n",
    "Caso queira consultar o retorno histórico diário, semanal ou mensal acesse o [link](https://www.investing.com/equities/ambev-pn-historical-data)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "#include <iomanip>\n",
    "\n",
    "#include \"csv.h\"\n",
    "#include \"setup.h\"\n",
    "\n",
    "#include \"ortools/linear_solver/linear_solver.h\"\n",
    "#include \"ortools/linear_solver/linear_solver.pb.h\"\n",
    "\n",
    "using namespace operations_research;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Símbolos de uma carteira\n",
    "\n",
    "Use a função getTickersByStartDate para retornar a lista de símbolos dos ativos existentes a partir de um determinado mês e ano."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "int getTickersByStartDate(int year, int month, std::vector<std::string> & selectedTickers)\n",
    "{\n",
    "    int months(0);\n",
    "    std::string initial_date(std::to_string(year) + \"-\" + (month<10 ? \"0\" + std::to_string(month) : std::to_string(month)) );\n",
    "    std::ifstream f1(\"ibovespa_desc.csv\");\n",
    "    auto tickers = csv_read_string(f1);\n",
    "    transpose<std::string>(tickers);\n",
    "    f1.close();\n",
    "\n",
    "    for(int ticker = 0; ticker < tickers[0].size(); ticker++){\n",
    "        auto filename = std::string(\"ibovespa2021/\") + tickers[0][ticker] + \"M.csv\";\n",
    "        std::ifstream f2(filename);\n",
    "\n",
    "        if (!f2.is_open())\n",
    "            continue;\n",
    "        \n",
    "        std::cout << \"Reading: \" << filename << std::endl;\n",
    "\n",
    "        auto returns = csv_read_string(f2);\n",
    "        transpose<std::string>(returns);\n",
    "        f2.close();\n",
    "        \n",
    "        int date_offset = -1;\n",
    "        for(int month=0; month<returns[0].size(); month++){\n",
    "            if (returns[0][month] == initial_date){\n",
    "                date_offset = month;\n",
    "                break;\n",
    "            } \n",
    "            else if (returns[0][month] > initial_date){\n",
    "                date_offset = -1;\n",
    "                break;\n",
    "            }\n",
    "        }\n",
    "        \n",
    "        if (date_offset >= 0) {\n",
    "            months = returns[0].size()-date_offset;\n",
    "            selectedTickers.push_back(tickers[0][ticker]);\n",
    "        }\n",
    "\n",
    "    }\n",
    "    return months;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading: ibovespa2021/ABEV3M.csv\n",
      "Reading: ibovespa2021/AZUL4M.csv\n",
      "Reading: ibovespa2021/B3SA3M.csv\n",
      "Reading: ibovespa2021/BBAS3M.csv\n",
      "Reading: ibovespa2021/BBDC3M.csv\n",
      "Reading: ibovespa2021/BBDC4M.csv\n",
      "Reading: ibovespa2021/BBSE3M.csv\n",
      "Reading: ibovespa2021/BEEF3M.csv\n",
      "Reading: ibovespa2021/BPAC11M.csv\n",
      "Reading: ibovespa2021/BRAP4M.csv\n",
      "Reading: ibovespa2021/BRDT3M.csv\n",
      "Reading: ibovespa2021/BRFS3M.csv\n",
      "Reading: ibovespa2021/BRKM5M.csv\n",
      "Reading: ibovespa2021/BRML3M.csv\n",
      "Reading: ibovespa2021/BTOW3M.csv\n",
      "Reading: ibovespa2021/CCRO3M.csv\n",
      "Reading: ibovespa2021/CIEL3M.csv\n",
      "Reading: ibovespa2021/CMIG4M.csv\n",
      "Reading: ibovespa2021/COGN3M.csv\n",
      "Reading: ibovespa2021/CPFE3M.csv\n",
      "Reading: ibovespa2021/CRFB3M.csv\n",
      "Reading: ibovespa2021/CSAN3M.csv\n",
      "Reading: ibovespa2021/CSNA3M.csv\n",
      "Reading: ibovespa2021/CVCB3M.csv\n",
      "Reading: ibovespa2021/CYRE3M.csv\n",
      "Reading: ibovespa2021/ECOR3M.csv\n",
      "Reading: ibovespa2021/EGIE3M.csv\n",
      "Reading: ibovespa2021/ELET3M.csv\n",
      "Reading: ibovespa2021/ELET6M.csv\n",
      "Reading: ibovespa2021/EMBR3M.csv\n",
      "Reading: ibovespa2021/ENBR3M.csv\n",
      "Reading: ibovespa2021/ENGI11M.csv\n",
      "Reading: ibovespa2021/EQTL3M.csv\n",
      "Reading: ibovespa2021/FLRY3M.csv\n",
      "Reading: ibovespa2021/GGBR4M.csv\n",
      "Reading: ibovespa2021/GNDI3M.csv\n",
      "Reading: ibovespa2021/GOAU4M.csv\n",
      "Reading: ibovespa2021/GOLL4M.csv\n",
      "Reading: ibovespa2021/HAPV3M.csv\n",
      "Reading: ibovespa2021/HGTX3M.csv\n",
      "Reading: ibovespa2021/HYPE3M.csv\n",
      "Reading: ibovespa2021/IGTA3M.csv\n",
      "Reading: ibovespa2021/IRBR3M.csv\n",
      "Reading: ibovespa2021/ITSA4M.csv\n",
      "Reading: ibovespa2021/ITUB4M.csv\n",
      "Reading: ibovespa2021/JBSS3M.csv\n",
      "Reading: ibovespa2021/KLBN11M.csv\n",
      "Reading: ibovespa2021/LAME4M.csv\n",
      "Reading: ibovespa2021/LREN3M.csv\n",
      "Reading: ibovespa2021/MGLU3M.csv\n",
      "Reading: ibovespa2021/MRFG3M.csv\n",
      "Reading: ibovespa2021/MRVE3M.csv\n",
      "Reading: ibovespa2021/MULT3M.csv\n",
      "Reading: ibovespa2021/NTCO3M.csv\n",
      "Reading: ibovespa2021/PETR3M.csv\n",
      "Reading: ibovespa2021/PETR4M.csv\n",
      "Reading: ibovespa2021/QUAL3M.csv\n",
      "Reading: ibovespa2021/RADL3M.csv\n",
      "Reading: ibovespa2021/RAIL3M.csv\n",
      "Reading: ibovespa2021/RENT3M.csv\n",
      "Reading: ibovespa2021/SANB11M.csv\n",
      "Reading: ibovespa2021/SBSP3M.csv\n",
      "Reading: ibovespa2021/SULA11M.csv\n",
      "Reading: ibovespa2021/TAEE11M.csv\n",
      "Reading: ibovespa2021/TIMS3M.csv\n",
      "Reading: ibovespa2021/TOTS3M.csv\n",
      "Reading: ibovespa2021/UGPA3M.csv\n",
      "Reading: ibovespa2021/USIM5M.csv\n",
      "Reading: ibovespa2021/VALE3M.csv\n",
      "Reading: ibovespa2021/VIVT4M.csv\n",
      "Reading: ibovespa2021/VVAR3M.csv\n",
      "Reading: ibovespa2021/WEGE3M.csv\n",
      "Reading: ibovespa2021/YDUQ3M.csv\n"
     ]
    }
   ],
   "source": [
    "std::vector<std::string> tickers;\n",
    "int months = getTickersByStartDate(2020, 9, tickers);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "73"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tickers.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Retorno de uma carteira\n",
    "\n",
    "Calcule o retorno médio mensal em percentual de cada ação baseado nos dados históricos fornecidos. Fica a critério de cada grupo escolher o intervalo mais apropriado de datas.\n",
    "\n",
    "    O algoritmo abaixo seleciona somente as ações de empresas listadas na Bovespa a partir de uma data configurada (initial_date)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "void getReturnsByTicker(const std::vector<std::string> & tickers, std::vector<std::vector<double>> & selectedReturns)\n",
    "{\n",
    "    for(int ticker = 0; ticker < tickers.size(); ticker++){\n",
    "        auto filename = std::string(\"ibovespa2021/\") + tickers[ticker] + \"M.csv\";\n",
    "        std::ifstream f2(filename);\n",
    "\n",
    "        if (!f2.is_open())\n",
    "            continue;\n",
    "\n",
    "        std::cout << \"Reading: \" << filename << std::endl;\n",
    "\n",
    "        auto returns = csv_read_string(f2);\n",
    "        transpose<std::string>(returns);\n",
    "        f2.close();\n",
    "        \n",
    "        int date_offset = returns[1].size() - selectedReturns[ticker].size();\n",
    "        \n",
    "        if (date_offset >= 0) {\n",
    "            for(int month=date_offset; month<returns[1].size(); month++) {\n",
    "                selectedReturns[ticker][month-date_offset] = std::stof(returns[1][month]);\n",
    "            }\n",
    "        }\n",
    "\n",
    "    }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading: ibovespa2021/ABEV3M.csv\n",
      "Reading: ibovespa2021/AZUL4M.csv\n",
      "Reading: ibovespa2021/B3SA3M.csv\n",
      "Reading: ibovespa2021/BBAS3M.csv\n",
      "Reading: ibovespa2021/BBDC3M.csv\n",
      "Reading: ibovespa2021/BBDC4M.csv\n",
      "Reading: ibovespa2021/BBSE3M.csv\n",
      "Reading: ibovespa2021/BEEF3M.csv\n",
      "Reading: ibovespa2021/BPAC11M.csv\n",
      "Reading: ibovespa2021/BRAP4M.csv\n",
      "Reading: ibovespa2021/BRDT3M.csv\n",
      "Reading: ibovespa2021/BRFS3M.csv\n",
      "Reading: ibovespa2021/BRKM5M.csv\n",
      "Reading: ibovespa2021/BRML3M.csv\n",
      "Reading: ibovespa2021/BTOW3M.csv\n",
      "Reading: ibovespa2021/CCRO3M.csv\n",
      "Reading: ibovespa2021/CIEL3M.csv\n",
      "Reading: ibovespa2021/CMIG4M.csv\n",
      "Reading: ibovespa2021/COGN3M.csv\n",
      "Reading: ibovespa2021/CPFE3M.csv\n",
      "Reading: ibovespa2021/CRFB3M.csv\n",
      "Reading: ibovespa2021/CSAN3M.csv\n",
      "Reading: ibovespa2021/CSNA3M.csv\n",
      "Reading: ibovespa2021/CVCB3M.csv\n",
      "Reading: ibovespa2021/CYRE3M.csv\n",
      "Reading: ibovespa2021/ECOR3M.csv\n",
      "Reading: ibovespa2021/EGIE3M.csv\n",
      "Reading: ibovespa2021/ELET3M.csv\n",
      "Reading: ibovespa2021/ELET6M.csv\n",
      "Reading: ibovespa2021/EMBR3M.csv\n",
      "Reading: ibovespa2021/ENBR3M.csv\n",
      "Reading: ibovespa2021/ENGI11M.csv\n",
      "Reading: ibovespa2021/EQTL3M.csv\n",
      "Reading: ibovespa2021/FLRY3M.csv\n",
      "Reading: ibovespa2021/GGBR4M.csv\n",
      "Reading: ibovespa2021/GNDI3M.csv\n",
      "Reading: ibovespa2021/GOAU4M.csv\n",
      "Reading: ibovespa2021/GOLL4M.csv\n",
      "Reading: ibovespa2021/HAPV3M.csv\n",
      "Reading: ibovespa2021/HGTX3M.csv\n",
      "Reading: ibovespa2021/HYPE3M.csv\n",
      "Reading: ibovespa2021/IGTA3M.csv\n",
      "Reading: ibovespa2021/IRBR3M.csv\n",
      "Reading: ibovespa2021/ITSA4M.csv\n",
      "Reading: ibovespa2021/ITUB4M.csv\n",
      "Reading: ibovespa2021/JBSS3M.csv\n",
      "Reading: ibovespa2021/KLBN11M.csv\n",
      "Reading: ibovespa2021/LAME4M.csv\n",
      "Reading: ibovespa2021/LREN3M.csv\n",
      "Reading: ibovespa2021/MGLU3M.csv\n",
      "Reading: ibovespa2021/MRFG3M.csv\n",
      "Reading: ibovespa2021/MRVE3M.csv\n",
      "Reading: ibovespa2021/MULT3M.csv\n",
      "Reading: ibovespa2021/NTCO3M.csv\n",
      "Reading: ibovespa2021/PETR3M.csv\n",
      "Reading: ibovespa2021/PETR4M.csv\n",
      "Reading: ibovespa2021/QUAL3M.csv\n",
      "Reading: ibovespa2021/RADL3M.csv\n",
      "Reading: ibovespa2021/RAIL3M.csv\n",
      "Reading: ibovespa2021/RENT3M.csv\n",
      "Reading: ibovespa2021/SANB11M.csv\n",
      "Reading: ibovespa2021/SBSP3M.csv\n",
      "Reading: ibovespa2021/SULA11M.csv\n",
      "Reading: ibovespa2021/TAEE11M.csv\n",
      "Reading: ibovespa2021/TIMS3M.csv\n",
      "Reading: ibovespa2021/TOTS3M.csv\n",
      "Reading: ibovespa2021/UGPA3M.csv\n",
      "Reading: ibovespa2021/USIM5M.csv\n",
      "Reading: ibovespa2021/VALE3M.csv\n",
      "Reading: ibovespa2021/VIVT4M.csv\n",
      "Reading: ibovespa2021/VVAR3M.csv\n",
      "Reading: ibovespa2021/WEGE3M.csv\n",
      "Reading: ibovespa2021/YDUQ3M.csv\n"
     ]
    }
   ],
   "source": [
    "std::vector<std::vector<double>> returns(tickers.size(), std::vector<double>(months));\n",
    "getReturnsByTicker(tickers, returns);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Retorno Médio e Risco de uma carteira\n",
    "\n",
    "Calcule a matriz de covariância considerando os retornos selecionados no passo anterior. \n",
    "\n",
    "Suponha que sejam consideradas $n$ ações para inclusão nessa carteira e façamos com que as variáveis de decisão $x_i$ ($i = 1, 2, ..., n$) representem o percentual da carteira que será alocado no ativo $i$. \n",
    "\n",
    "Estipulamos que $\\mu_i$ e $\\sigma_{ii}$ sejam, respectivamente, a média e a variância, (estimadas) do retorno sobre cada cota da ação i, em que $\\sigma_{ii}$ mede o risco dessa ação.\n",
    "\n",
    "Para $i=1,2,...,n$ ($i \\ne j$),façamos com que $\\sigma_{ij}$ represente a co-variância do retorno sobre cada cota da ação i e j. \n",
    "\n",
    "Como seria difícil estimar todos os valores $\\sigma_{ij}$, a metodologia usual é partir de certas hipóteses sobre o comportamento do mercado que nos permitam calcular $\\sigma_{ij}$ diretamente de $\\sigma_{ii}$ e $\\sigma_{jj}$.\n",
    "\n",
    "A seguir, o valor esperado $R(x)$ e a variância $V(x)$ do retorno total de toda a carteira são:\n",
    "\n",
    "$R(x) = \\sum_{j=1}^n \\mu_{j}x_j$\n",
    "\n",
    "e\n",
    "\n",
    "$V(x) = \\sum_{i=1}^n \\sum_{j=1}^n \\sigma_{ij}x_i x_j$\n",
    "\n",
    "em que $V(x)$ mede o risco associado à carteira com base na matriz de covariância $\\Sigma$, $N\\times N$:\n",
    "\n",
    "$$ \\Sigma = \\left[\\begin{matrix}\n",
    "VAR(R_1) & COV(R_1, R_2) & \\cdots & COV(R_1, R_N) \\\\\n",
    "COV(R_2, R_0) & VAR(R_2) & \\cdots & COV(R_2, R_N) \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "COV(R_N, R_1) & COV(R_N, R_2) & \\cdots & VAR(R_N)\n",
    "\\end{matrix}\\right] $$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "void getMeanCovariance(const std::vector<std::vector<double>> &x, std::vector<double> &average, std::vector<std::vector<double>> &covmatrix){\n",
    "    auto const n = x.size(); //tickers\n",
    "    auto const m = x[0].size()-1; //months\n",
    "    for (int i = 0; i < n; i++){\n",
    "        double sum = 0;\n",
    "        for (int k = 0; k < m; k++)\n",
    "            sum += x[i][k];\n",
    "        average.push_back(sum / (double)m);\n",
    "    }\n",
    "\n",
    "    for (int i = 0; i < n; i++){\n",
    "        std::vector<double>temp;\n",
    "        for (int j = 0; j < n; j++){\n",
    "            double sum = 0;\n",
    "            for (int k = 0; k < m; k++)\n",
    "                sum += (x[i][k] - average[i])*(x[j][k] - average[j]);\n",
    "            temp.push_back(sum / (double)(m));\n",
    "        }\n",
    "        covmatrix.push_back(temp);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "auto getPortfolioReturn(const std::vector<std::string> &portfolio_tickers, \n",
    "                        const std::vector<double> &portfolio_weights){\n",
    "    auto portfolio_returns = 0.0;\n",
    "    for(int i=0; i < portfolio_tickers.size(); i++){\n",
    "        for(int j=0; j < tickers.size(); j++) {\n",
    "            if (portfolio_tickers[i] == tickers[j]) {\n",
    "                portfolio_returns += portfolio_weights[i] * returns[j][returns[j].size()-1];\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "    return portfolio_returns;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Otimização de Carteira de Investimentos\n",
    "\n",
    "O objetivo é analisar as cotações históricas das ações do Ibovespa segundo a Moderna Teoria de Portfolio para gerar uma distribuição de alocação ótima (em percentual) composta de 5 a 10 ativos para ser utilizada na carteira mensal de Setembro de 2020. \n",
    "\n",
    "**Importante:** Os grupos cujas carteiras otimizadas alcançarem os maiores retornos (positivos) em Setembro/2020 receberão pontuação extra proporcional ao rendimento alcançado.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "std::vector<double> mean;\n",
    "std::vector<std::vector<double>> covariance;\n",
    "getMeanCovariance(returns, mean, covariance);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.031411293"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"ABEV3\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tickers[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "std::vector<std::string> portfolio_tickers;\n",
    "std::vector<double> portfolio_weights;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escolha uma das duas modelagens abaixo e justifique:\n",
    "\n",
    "Minimizar: $x^T\\sum x$\n",
    "\n",
    "Minimizar: $\\sum_{i=1}^n \\sum_{j=1}^n \\sigma_{ij}x_i x_j$\n",
    "\n",
    "\n",
    "Sujeito a: \n",
    "\n",
    "$\n",
    "\\begin{align}\n",
    "\\mu^Tx \\ge r_{min} \\\\\n",
    "1^Tx \\le 1  \\\\\n",
    "x \\ge 0\n",
    "\\end{align}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solução ótima encontrada!\n",
      "Retorno = 2.00% (a.m.) \n",
      "AZUL4 = 0.12\n",
      "BRKM5 = 0.07\n",
      "BTOW3 = 0.07\n",
      "EMBR3 = 0.04\n",
      "GGBR4 = 0.11\n",
      "HAPV3 = 0.10\n",
      "HGTX3 = 0.11\n",
      "USIM5 = 0.05\n",
      "VVAR3 = 0.09\n",
      "WEGE3 = 0.22\n"
     ]
    }
   ],
   "source": [
    "{\n",
    "    const double infinity = MPSolver::infinity();\n",
    "    \n",
    "    // max and min portfolio allocation\n",
    "    auto net_upper_long_bound=1.0;\n",
    "    auto net_lower_long_bound=0.5;\n",
    "    auto r_min = 0.02;\n",
    "    auto n = tickers.size();\n",
    "    \n",
    "    MPModelRequest model_request;\n",
    "    \n",
    "    model_request.set_solver_type(MPModelRequest::SCIP_MIXED_INTEGER_PROGRAMMING);\n",
    "    \n",
    "    auto model_proto = model_request.mutable_model();\n",
    "\n",
    "    model_proto->set_name(\"Min Portfolio Otimization\");\n",
    "    model_proto->set_maximize(false);\n",
    "   \n",
    "    std::vector<MPVariableProto*> x(n);\n",
    "    for(auto i = 0; i < n; i++) {\n",
    "        x[i] = model_proto->add_variable();\n",
    "        x[i]->set_name(tickers[i]);  \n",
    "        x[i]->set_upper_bound(1);  \n",
    "        x[i]->set_lower_bound(0);//long only\n",
    "        x[i]->set_objective_coefficient(0); //FO: 0\n",
    "        x[i]->set_is_integer(false);      \n",
    "    }\n",
    "    \n",
    "    //FO: sum(sigma[i][j] * x[i] * x[j])\n",
    "    auto quad_obj = model_proto->mutable_quadratic_objective();\n",
    "    for(auto i = 0; i < n; i++) {\n",
    "        for(auto j = 0; j < n; j++) {\n",
    "            quad_obj->add_qvar1_index(i);\n",
    "            quad_obj->add_qvar2_index(j);\n",
    "            quad_obj->add_coefficient(covariance[i][j]);\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    //Constraint: net_lower_long_bound <= sum(x[i]) <= net_upper_long_bound\n",
    "    auto c = model_proto->add_constraint();\n",
    "    c->set_name(\"c\");  \n",
    "    c->set_lower_bound(net_lower_long_bound);    \n",
    "    c->set_upper_bound(net_upper_long_bound);\n",
    "    for(auto i = 0; i < n; i++) {\n",
    "        c->add_var_index(i);\n",
    "        c->add_coefficient(1);\n",
    "    }\n",
    "    \n",
    "    //Constraint: sum(mean_return[i] * x[i]) >= r_min\n",
    "    auto r = model_proto->add_constraint();\n",
    "    r->set_name(\"r\");  \n",
    "    r->set_lower_bound(r_min);    \n",
    "    r->set_upper_bound(infinity);\n",
    "    for(auto i = 0; i < n; i++) {\n",
    "        r->add_var_index(i);\n",
    "        r->add_coefficient(mean[i]);\n",
    "    }\n",
    "    \n",
    "    MPSolutionResponse solution_response;\n",
    "    MPSolver::SolveWithProto(model_request, &solution_response);\n",
    "\n",
    "    if (solution_response.status() == MPSOLVER_OPTIMAL) {\n",
    "        std::cout << \"Solução ótima encontrada!\" << std::endl;\n",
    "    \n",
    "        std::vector<double> solution(n);\n",
    "        for (int i = 0; i < n; i++) \n",
    "            solution[i] = solution_response.variable_value(i);\n",
    "\n",
    "        double rs = std::inner_product(mean.begin(), mean.end(), solution.begin(), 0.0);\n",
    "\n",
    "        std::cout << \"Retorno = \" << std::fixed << std::setprecision(2) << rs*100.0 << \"% (a.m.) \" << std::endl;\n",
    "\n",
    "        portfolio_tickers.clear();\n",
    "        portfolio_weights.clear();\n",
    "        for (int i = 0; i < n; i++) {\n",
    "            if (solution[i] >= 0.01) {\n",
    "                portfolio_tickers.push_back(tickers[i]);\n",
    "                portfolio_weights.push_back(solution[i]);\n",
    "                std::cout << tickers[i] << \" = \" << solution[i] << std::endl;\n",
    "            }\n",
    "        }\n",
    "    } else {\n",
    "        std::cout << \"Solução não encontrada!\" << std::endl;\n",
    "    }\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.54% (a.m.)"
     ]
    }
   ],
   "source": [
    "std::cout << getPortfolioReturn(portfolio_tickers, portfolio_weights)*100.0 << \"% (a.m.)\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Maximizar: $\\mu^Tx - \\rho x^T\\sum x$\n",
    "\n",
    "Maximizar: $\\sum_{i=1}^n \\mu_i x_i - \\rho \\sum_{i=1}^n \\sum_{j=1}^n \\sigma_{ij}x_i x_j$\n",
    "\n",
    "\n",
    "Sujeito a: \n",
    "\n",
    "$\n",
    "\\begin{align}\n",
    "1^Tx \\le 1  \\\\\n",
    "x \\ge 0\n",
    "\\end{align}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solução Ótima!\n",
      "Retorno = 11.12% (a.m.) \n",
      "BRKM5 = 0.11\n",
      "CSNA3 = 0.72\n",
      "EMBR3 = 0.17\n"
     ]
    }
   ],
   "source": [
    "{\n",
    "    // max and min portfolio allocation\n",
    "    auto net_upper_long_bound=1.0;\n",
    "    auto net_lower_long_bound=0.5;\n",
    "    \n",
    "    // risk/reward tradeoff input, higher means less risk, b/t .1 & 1\n",
    "    auto rho = 1.0;\n",
    "    \n",
    "    //std::cout << \"Informe um dos valores para rho [0.1, 0.5, 1.0, 10.0]:\";\n",
    "    //std::cin >> rho;\n",
    "        \n",
    "    auto n = tickers.size();\n",
    "    \n",
    "    MPModelRequest model_request;\n",
    "    \n",
    "    model_request.set_solver_type(MPModelRequest::SCIP_MIXED_INTEGER_PROGRAMMING);\n",
    "    \n",
    "    auto model_proto = model_request.mutable_model();\n",
    "\n",
    "    model_proto->set_name(\"Portfolio Otimization\");\n",
    "    model_proto->set_maximize(true);\n",
    "   \n",
    "    std::vector<MPVariableProto*> x(n);\n",
    "    for(auto i = 0; i < n; i++) {\n",
    "        x[i] = model_proto->add_variable();\n",
    "        x[i]->set_name(tickers[i]);  \n",
    "        x[i]->set_upper_bound(1);  \n",
    "        x[i]->set_lower_bound(0);//long only\n",
    "        x[i]->set_objective_coefficient(mean[i]); //FO: sum(mean_return[i] * x[i])\n",
    "        x[i]->set_is_integer(false);      \n",
    "    }\n",
    "    \n",
    "    //FO: - rho * sum(sigma[i][j] * x[i] * x[j])\n",
    "    auto quad_obj = model_proto->mutable_quadratic_objective();\n",
    "    for(auto i = 0; i < n; i++) {\n",
    "        for(auto j = 0; j < n; j++) {\n",
    "            quad_obj->add_qvar1_index(i);\n",
    "            quad_obj->add_qvar2_index(j);\n",
    "            quad_obj->add_coefficient(-rho*covariance[i][j]);\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    //Constraint: net_lower_long_bound <= sum(x[i]) <= net_upper_long_bound\n",
    "    auto c = model_proto->add_constraint();\n",
    "    c->set_name(\"c\");  \n",
    "    c->set_lower_bound(net_lower_long_bound);    \n",
    "    c->set_upper_bound(net_upper_long_bound);\n",
    "    for(auto i = 0; i < n; i++) {\n",
    "        c->add_var_index(i);\n",
    "        c->add_coefficient(1);\n",
    "    }\n",
    "    \n",
    "    MPSolutionResponse solution_response;\n",
    "    MPSolver::SolveWithProto(model_request, &solution_response);\n",
    "\n",
    "    if (solution_response.status() == MPSOLVER_OPTIMAL) {\n",
    "        std::cout << \"Solução Ótima!\" << std::endl;\n",
    "    \n",
    "        std::vector<double> solution(2*n);\n",
    "        for (int i = 0; i < n; i++) \n",
    "            solution[i] = solution_response.variable_value(i);\n",
    "\n",
    "        double rs = std::inner_product(mean.begin(), mean.end(), solution.begin(), 0.0);\n",
    "\n",
    "        std::cout << \"Retorno = \" << std::fixed << std::setprecision(2) << rs*100.0 << \"% (a.m.) \" << std::endl;\n",
    "\n",
    "        portfolio_tickers.clear();\n",
    "        portfolio_weights.clear();\n",
    "        for (int i = 0; i < n; i++) {\n",
    "            if (solution[i] >= 0.01) {\n",
    "                portfolio_tickers.push_back(tickers[i]);\n",
    "                portfolio_weights.push_back(solution[i]);\n",
    "                std::cout << tickers[i] << \" = \" << solution[i] << std::endl;\n",
    "            }\n",
    "        }\n",
    "    } else {\n",
    "        std::cout << \"Solução não encontrada!\" << std::endl;\n",
    "    }\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A otimização deverá retornar o vetor $x$ contendo apenas entre 5 e 10 ativos selecionados automaticamente pelo solver."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-12.40% (a.m.)"
     ]
    }
   ],
   "source": [
    "std::cout << getPortfolioReturn(portfolio_tickers, portfolio_weights)*100.0 << \"% (a.m.)\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12% (a.m.)"
     ]
    }
   ],
   "source": [
    "//GRUPO A\n",
    "{\n",
    "    std::vector<std::string> portfolio_tickers {\"BEEF3\",\"BRKM5\",\"CSAN3\",\"HGTX3\",\"JBSS3\",\"MRFG3\",\"TOTS3\",\"WEGE3\"};\n",
    "    std::vector<double> portfolio_weights {0.04,0.02,0.09,0.02,0.05,0.07,0.19,0.28};\n",
    "    std::cout << getPortfolioReturn(portfolio_tickers, portfolio_weights)*100.0 << \"% (a.m.)\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12% (a.m.)"
     ]
    }
   ],
   "source": [
    "//GRUPO B\n",
    "{\n",
    "    std::vector<std::string> portfolio_tickers {\"BEEF3\",\"BRKM5\",\"CSAN3\",\"HGTX3\",\"JBSS3\",\"MRFG3\",\"TOTS3\",\"WEGE3\"};\n",
    "    std::vector<double> portfolio_weights {0.04,0.02,0.09,0.02,0.05,0.07,0.19,0.28};\n",
    "    std::cout << getPortfolioReturn(portfolio_tickers, portfolio_weights)*100.0 << \"% (a.m.)\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.43% (a.m.)"
     ]
    }
   ],
   "source": [
    "//GRUPO C\n",
    "{\n",
    "    std::vector<std::string> portfolio_tickers {\"BRKM5\",\"CSAN3\",\"ELET3\",\"HGTX3\",\"MRFG3\",\"TOTS3\",\"WEGE3\"};\n",
    "    std::vector<double> portfolio_weights {0.05,0.15,0.04,0.02,0.02,0.10,0.29};\n",
    "    std::cout << getPortfolioReturn(portfolio_tickers, portfolio_weights)*100.0 << \"% (a.m.)\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12% (a.m.)"
     ]
    }
   ],
   "source": [
    "//GRUPO D\n",
    "{\n",
    "    std::vector<std::string> portfolio_tickers {\"BEEF3\",\"BRKM5\",\"CSAN3\",\"HGTX3\",\"JBSS3\",\"MRFG3\",\"TOTS3\",\"WEGE3\"};\n",
    "    std::vector<double> portfolio_weights {0.04,0.02,0.09,0.02,0.05,0.07,0.19,0.28};\n",
    "    std::cout << getPortfolioReturn(portfolio_tickers, portfolio_weights)*100.0 << \"% (a.m.)\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12% (a.m.)"
     ]
    }
   ],
   "source": [
    "//GRUPO E\n",
    "{\n",
    "    std::vector<std::string> portfolio_tickers {\"BEEF3\",\"BRKM5\",\"CSAN3\",\"HGTX3\",\"JBSS3\",\"MRFG3\",\"TOTS3\",\"WEGE3\"};\n",
    "    std::vector<double> portfolio_weights {0.04,0.02,0.09,0.02,0.05,0.07,0.19,0.28};\n",
    "    std::cout << getPortfolioReturn(portfolio_tickers, portfolio_weights)*100.0 << \"% (a.m.)\";\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++14",
   "language": "C++14",
   "name": "xcpp14"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}