financial_planning_tools.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Financial Planning with APIs and Simulations\n",
    "\n",
    "In this Challenge, you’ll create two financial analysis tools by using a single Jupyter notebook:\n",
    "\n",
    "Part 1: A financial planner for emergencies. The members will be able to use this tool to visualize their current savings. The members can then determine if they have enough reserves for an emergency fund.\n",
    "\n",
    "Part 2: A financial planner for retirement. This tool will forecast the performance of their retirement portfolio in 30 years. To do this, the tool will make an Alpaca API call via the Alpaca SDK to get historical price data for use in Monte Carlo simulations.\n",
    "\n",
    "You’ll use the information from the Monte Carlo simulation to answer questions about the portfolio in your Jupyter notebook.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the required libraries and dependencies\n",
    "import os\n",
    "import requests\n",
    "import json\n",
    "import pandas as pd\n",
    "from dotenv import load_dotenv\n",
    "import alpaca_trade_api as tradeapi\n",
    "from MCForecastTools import MCSimulation\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the environment variables from the .env file\n",
    "#by calling the load_dotenv function\n",
    "load_dotenv(\"fin_plan.env\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: Create a Financial Planner for Emergencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate the Cryptocurrency Wallet by Using the Requests Library\n",
    "\n",
    "In this section, you’ll determine the current value of a member’s cryptocurrency wallet. You’ll collect the current prices for the Bitcoin and Ethereum cryptocurrencies by using the Python Requests library. For the prototype, you’ll assume that the member holds the 1.2 Bitcoins (BTC) and 5.3 Ethereum coins (ETH). To do all this, complete the following steps:\n",
    "\n",
    "1. Create a variable named `monthly_income`, and set its value to `12000`.\n",
    "\n",
    "2. Use the Requests library to get the current price (in US dollars) of Bitcoin (BTC) and Ethereum (ETH) by using the API endpoints that the starter code supplies.\n",
    "\n",
    "3. Navigate the JSON response object to access the current price of each coin, and store each in a variable.\n",
    "\n",
    "    > **Hint** Note the specific identifier for each cryptocurrency in the API JSON response. The Bitcoin identifier is `1`, and the Ethereum identifier is `1027`.\n",
    "\n",
    "4. Calculate the value, in US dollars, of the current amount of each cryptocurrency and of the entire cryptocurrency wallet.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The current number of coins for each cryptocurrency asset held in the portfolio.\n",
    "btc_coins = 1.2\n",
    "eth_coins = 5.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 1: Create a variable named `monthly_income`, and set its value to `12000`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The monthly amount for the member's household income\n",
    "# YOUR CODE HERE\n",
    "monthly_income = 12000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Review the endpoint URLs for the API calls to Free Crypto API in order to get the current pricing information for both BTC and ETH."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Free Crypto API Call endpoint URLs for the held cryptocurrency assets\n",
    "btc_url = \"https://api.alternative.me/v2/ticker/Bitcoin/?convert=USD\"\n",
    "eth_url = \"https://api.alternative.me/v2/ticker/Ethereum/?convert=USD\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 2. Use the Requests library to get the current price (in US dollars) of Bitcoin (BTC) and Ethereum (ETH) by using the API endpoints that the starter code supplied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"data\": {\n",
      "    \"1\": {\n",
      "      \"circulating_supply\": 19046887,\n",
      "      \"id\": 1,\n",
      "      \"last_updated\": 1653269913,\n",
      "      \"max_supply\": 21000000,\n",
      "      \"name\": \"Bitcoin\",\n",
      "      \"quotes\": {\n",
      "        \"USD\": {\n",
      "          \"market_cap\": 576113028518,\n",
      "          \"percent_change_1h\": -0.117091098244188,\n",
      "          \"percent_change_24h\": 2.40223981850572,\n",
      "          \"percent_change_7d\": -3.36662393102156,\n",
      "          \"percentage_change_1h\": -0.117091098244188,\n",
      "          \"percentage_change_24h\": 2.40223981850572,\n",
      "          \"percentage_change_7d\": -3.36662393102156,\n",
      "          \"price\": 30265.0,\n",
      "          \"volume_24h\": 17742146674\n",
      "        }\n",
      "      },\n",
      "      \"rank\": 1,\n",
      "      \"symbol\": \"BTC\",\n",
      "      \"total_supply\": 19046887,\n",
      "      \"website_slug\": \"bitcoin\"\n",
      "    }\n",
      "  },\n",
      "  \"metadata\": {\n",
      "    \"error\": null,\n",
      "    \"num_cryptocurrencies\": 3106,\n",
      "    \"timestamp\": 1653269913\n",
      "  }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "# Using the Python requests library, make an API call to access the current price of BTC\n",
    "btc_response = requests.get(btc_url).json()\n",
    "\n",
    "# Use the json.dumps function to review the response data from the API call\n",
    "# Use the indent and sort_keys parameters to make the response object readable\n",
    "# YOUR CODE HERE\n",
    "print(json.dumps(btc_response, indent = 2, sort_keys = True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"data\": {\n",
      "    \"1027\": {\n",
      "      \"circulating_supply\": 120885865,\n",
      "      \"id\": 1027,\n",
      "      \"last_updated\": 1653269909,\n",
      "      \"max_supply\": 0,\n",
      "      \"name\": \"Ethereum\",\n",
      "      \"quotes\": {\n",
      "        \"USD\": {\n",
      "          \"market_cap\": 246207197199,\n",
      "          \"percent_change_1h\": -0.28591874134433,\n",
      "          \"percent_change_24h\": 2.66522188978851,\n",
      "          \"percent_change_7d\": -5.1058772711282,\n",
      "          \"percentage_change_1h\": -0.28591874134433,\n",
      "          \"percentage_change_24h\": 2.66522188978851,\n",
      "          \"percentage_change_7d\": -5.1058772711282,\n",
      "          \"price\": 2037.42,\n",
      "          \"volume_24h\": 10031323749\n",
      "        }\n",
      "      },\n",
      "      \"rank\": 2,\n",
      "      \"symbol\": \"ETH\",\n",
      "      \"total_supply\": 120885865,\n",
      "      \"website_slug\": \"ethereum\"\n",
      "    }\n",
      "  },\n",
      "  \"metadata\": {\n",
      "    \"error\": null,\n",
      "    \"num_cryptocurrencies\": 3106,\n",
      "    \"timestamp\": 1653269909\n",
      "  }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "# Using the Python requests library, make an API call to access the current price ETH\n",
    "eth_response = requests.get(eth_url).json()\n",
    "\n",
    "# Use the json.dumps function to review the response data from the API call\n",
    "# Use the indent and sort_keys parameters to make the response object readable\n",
    "print(json.dumps(eth_response, indent = 2, sort_keys = True))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3: Navigate the JSON response object to access the current price of each coin, and store each in a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BTC current price: $30265.0\n"
     ]
    }
   ],
   "source": [
    "# Navigate the BTC response object to access the current price of BTC\n",
    "btc_price = btc_response[\"data\"][\"1\"][\"quotes\"][\"USD\"][\"price\"]\n",
    "\n",
    "# Print the current price of BTC\n",
    "# YOUR CODE HERE\n",
    "print(f\"BTC current price: ${btc_price}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ETH current price: $2037.42\n"
     ]
    }
   ],
   "source": [
    "# Navigate the ETH response object to access the current price of ETH\n",
    "eth_price = eth_response[\"data\"][\"1027\"][\"quotes\"][\"USD\"][\"price\"]\n",
    "\n",
    "# Print the current price of ETH\n",
    "# YOUR CODE HERE\n",
    "print(f\"ETH current price: ${eth_price}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4: Calculate the value, in US dollars, of the current amount of each cryptocurrency and of the entire cryptocurrency wallet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current value of BTC holdings: $36318.0 USD\n"
     ]
    }
   ],
   "source": [
    "# Compute the current value of the BTC holding \n",
    "btc_value = btc_price * btc_coins\n",
    "\n",
    "# Print current value of your holding in BTC\n",
    "# YOUR CODE HERE\n",
    "print(f\"Current value of BTC holdings: ${btc_value} USD\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current value of ETH holdings: $10798.326000000001 USD\n"
     ]
    }
   ],
   "source": [
    "# Compute the current value of the ETH holding \n",
    "eth_value = eth_price * eth_coins\n",
    "\n",
    "# Print current value of your holding in ETH\n",
    "# YOUR CODE HERE\n",
    "print(f\"Current value of ETH holdings: ${eth_value} USD\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current cryptocurrency wallet balance: $47116.326 USD\n"
     ]
    }
   ],
   "source": [
    "# Compute the total value of the cryptocurrency wallet\n",
    "# Add the value of the BTC holding to the value of the ETH holding\n",
    "total_crypto_wallet = btc_value + eth_value\n",
    "\n",
    "# Print current cryptocurrency wallet balance\n",
    "# YOUR CODE HERE\n",
    "print(f\"Current cryptocurrency wallet balance: ${total_crypto_wallet} USD\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate the Stock and Bond Holdings by Using the Alpaca SDK\n",
    "\n",
    "In this section, you’ll determine the current value of a member’s stock and bond holdings. You’ll make an API call to Alpaca via the Alpaca SDK to get the current closing prices of the SPDR S&P 500 ETF Trust (ticker: SPY) and of the iShares Core US Aggregate Bond ETF (ticker: AGG). For the prototype, assume that the member holds 110 shares of SPY, which represents the stock portion of their portfolio, and 200 shares of AGG, which represents the bond portion. To do all this, complete the following steps:\n",
    "\n",
    "1. In the `Starter_Code` folder, create an environment file (`.env`) to store the values of your Alpaca API key and Alpaca secret key.\n",
    "\n",
    "2. Set the variables for the Alpaca API and secret keys. Using the Alpaca SDK, create the Alpaca `tradeapi.REST` object. In this object, include the parameters for the Alpaca API key, the secret key, and the version number.\n",
    "\n",
    "3. Set the following parameters for the Alpaca API call:\n",
    "\n",
    "    - `tickers`: Use the tickers for the member’s stock and bond holdings.\n",
    "\n",
    "    - `timeframe`: Use a time frame of one day.\n",
    "\n",
    "    - `start_date` and `end_date`: Use the same date for these parameters, and format them with the date of the previous weekday (or `2020-08-07`). This is because you want the one closing price for the most-recent trading day.\n",
    "\n",
    "4. Get the current closing prices for `SPY` and `AGG` by using the Alpaca `get_bars` function. Format the response as a Pandas DataFrame by including the `df` property at the end of the `get_bars` function.\n",
    "\n",
    "5. Navigating the Alpaca response DataFrame, select the `SPY` and `AGG` closing prices, and store them as variables.\n",
    "\n",
    "6. Calculate the value, in US dollars, of the current amount of shares in each of the stock and bond portions of the portfolio, and print the results.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Review the total number of shares held in both (SPY) and (AGG)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Current amount of shares held in both the stock (SPY) and bond (AGG) portion of the portfolio.\n",
    "spy_shares = 110\n",
    "agg_shares = 200\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 1: In the `Starter_Code` folder, create an environment file (`.env`) to store the values of your Alpaca API key and Alpaca secret key."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 2: Set the variables for the Alpaca API and secret keys. Using the Alpaca SDK, create the Alpaca `tradeapi.REST` object. In this object, include the parameters for the Alpaca API key, the secret key, and the version number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the variables for the Alpaca API and secret keys\n",
    "# YOUR CODE HERE\n",
    "alpaca_api_key = os.getenv(\"ALPACA_API_KEY\")\n",
    "\n",
    "# YOUR CODE HERE\n",
    "alpaca_api_secret = os.getenv(\"ALPACA_SECRET_KEY\")\n",
    "\n",
    "# Create the Alpaca tradeapi.REST object\n",
    "# YOUR CODE HERE\n",
    "alpaca = tradeapi.REST(alpaca_api_key, alpaca_api_secret, api_version = \"v2\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3: Set the following parameters for the Alpaca API call:\n",
    "\n",
    "- `tickers`: Use the tickers for the member’s stock and bond holdings.\n",
    "\n",
    "- `timeframe`: Use a time frame of one day.\n",
    "\n",
    "- `start_date` and `end_date`: Use the same date for these parameters, and format them with the date of the previous weekday (or `2020-08-07`). This is because you want the one closing price for the most-recent trading day.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the tickers for both the bond and stock portion of the portfolio\n",
    "# YOUR CODE HERE\n",
    "tickers = [\"AGG\", \"SPY\"]\n",
    "\n",
    "# Set timeframe to 1Day\n",
    "# YOUR CODE HERE\n",
    "timeframe = \"1Day\"\n",
    "\n",
    "# Format current date as ISO format\n",
    "# Set both the start and end date at the date of your prior weekday \n",
    "# This will give you the closing price of the previous trading day\n",
    "# Alternatively you can use a start and end date of 2020-08-07\n",
    "# YOUR CODE HERE\n",
    "start_date = pd.Timestamp('2022-05-20',tz='America/New_York').isoformat()\n",
    "\n",
    "# YOUR CODE HERE\n",
    "end_date = pd.Timestamp('2022-05-20',tz='America/New_York').isoformat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 4: Get the current closing prices for `SPY` and `AGG` by using the Alpaca `get_bars` function. Format the response as a Pandas DataFrame by including the `df` property at the end of the `get_bars` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"7\" halign=\"left\">AGG</th>\n",
       "      <th colspan=\"7\" halign=\"left\">SPY</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</th>\n",
       "      <th>trade_count</th>\n",
       "      <th>vwap</th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</th>\n",
       "      <th>trade_count</th>\n",
       "      <th>vwap</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>timestamp</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2022-05-20 04:00:00+00:00</th>\n",
       "      <td>102.95</td>\n",
       "      <td>103.21</td>\n",
       "      <td>102.8801</td>\n",
       "      <td>103.16</td>\n",
       "      <td>6727473</td>\n",
       "      <td>22286</td>\n",
       "      <td>103.102608</td>\n",
       "      <td>393.0</td>\n",
       "      <td>397.03</td>\n",
       "      <td>380.54</td>\n",
       "      <td>389.63</td>\n",
       "      <td>130138587</td>\n",
       "      <td>1094303</td>\n",
       "      <td>387.046352</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                              AGG                                     \\\n",
       "                             open    high       low   close   volume   \n",
       "timestamp                                                              \n",
       "2022-05-20 04:00:00+00:00  102.95  103.21  102.8801  103.16  6727473   \n",
       "\n",
       "                                                     SPY                  \\\n",
       "                          trade_count        vwap   open    high     low   \n",
       "timestamp                                                                  \n",
       "2022-05-20 04:00:00+00:00       22286  103.102608  393.0  397.03  380.54   \n",
       "\n",
       "                                                                      \n",
       "                            close     volume trade_count        vwap  \n",
       "timestamp                                                             \n",
       "2022-05-20 04:00:00+00:00  389.63  130138587     1094303  387.046352  "
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the Alpaca get_bars function to get current closing prices the portfolio\n",
    "# Be sure to set the `df` property after the function to format the response object as a DataFrame\n",
    "# YOUR CODE HERE\n",
    "alpaca_df = alpaca.get_bars(tickers, timeframe, start = start_date, end = end_date).df\n",
    "\n",
    "# Reorganize the DataFrame\n",
    "# Separate ticker data\n",
    "# YOUR CODE HERE\n",
    "SPY = alpaca_df[alpaca_df[\"symbol\"] == \"SPY\"].drop(\"symbol\", axis = 1)\n",
    "AGG = alpaca_df[alpaca_df[\"symbol\"] == \"AGG\"].drop(\"symbol\", axis = 1)\n",
    "\n",
    "# Concatenate the ticker DataFrames\n",
    "# YOUR CODE HERE\n",
    "alpaca_df = pd.concat([AGG, SPY], axis = 1, keys = [\"AGG\", \"SPY\"])\n",
    "\n",
    "# Review the first 5 rows of the Alpaca DataFrame\n",
    "# YOUR CODE HERE\n",
    "alpaca_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 5: Navigating the Alpaca response DataFrame, select the `SPY` and `AGG` closing prices, and store them as variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AGG closing price: $103.16 USD\n"
     ]
    }
   ],
   "source": [
    "# Access the closing price for AGG from the Alpaca DataFrame\n",
    "# Converting the value to a floating point number\n",
    "agg_close_price = alpaca_df[\"AGG\"][\"close\"].values[0]\n",
    "\n",
    "# Print the AGG closing price\n",
    "# YOUR CODE HERE\n",
    "print(f\"AGG closing price: ${agg_close_price} USD\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SPY closing price: $389.63 USD\n"
     ]
    }
   ],
   "source": [
    "# Access the closing price for SPY from the Alpaca DataFrame\n",
    "# Converting the value to a floating point number\n",
    "spy_close_price = alpaca_df[\"SPY\"][\"close\"].values[0]\n",
    "\n",
    "# Print the SPY closing price\n",
    "# YOUR CODE HERE\n",
    "print(f\"SPY closing price: ${spy_close_price} USD\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 6: Calculate the value, in US dollars, of the current amount of shares in each of the stock and bond portions of the portfolio, and print the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current value of the AGG portfolio: $20632.0 USD\n"
     ]
    }
   ],
   "source": [
    "# Calculate the current value of the bond portion of the portfolio\n",
    "agg_value = agg_close_price * agg_shares\n",
    "\n",
    "# Print the current value of the bond portfolio\n",
    "# YOUR CODE HERE\n",
    "print(f\"Current value of the AGG portfolio: ${agg_value} USD\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current value of the SPY portfolio: $42859.3 USD\n"
     ]
    }
   ],
   "source": [
    "# Calculate the current value of the stock portion of the portfolio\n",
    "spy_value = spy_close_price * spy_shares\n",
    "\n",
    "# Print the current value of the stock portfolio\n",
    "# YOUR CODE HERE\n",
    "print(f\"Current value of the SPY portfolio: ${spy_value} USD\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current balance of the stock and bond portion of the portfolio: $63491.30 USD\n"
     ]
    }
   ],
   "source": [
    "# Calculate the total value of the stock and bond portion of the portfolio\n",
    "total_stocks_bonds = agg_value + spy_value\n",
    "\n",
    "# Print the current balance of the stock and bond portion of the portfolio\n",
    "# YOUR CODE HERE\n",
    "print(f\"Current balance of the stock and bond portion of the portfolio: ${total_stocks_bonds:.2f} USD\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total value of the member's entire savings portfolio: $110607.63 USD\n"
     ]
    }
   ],
   "source": [
    "# Calculate the total value of the member's entire savings portfolio\n",
    "# Add the value of the cryptocurrency walled to the value of the total stocks and bonds\n",
    "total_portfolio = total_stocks_bonds + total_crypto_wallet\n",
    "\n",
    "# Print current cryptocurrency wallet balance\n",
    "# YOUR CODE HERE\n",
    "print(f\"Total value of the member's entire savings portfolio: ${total_portfolio:.2f} USD\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate the Emergency Fund\n",
    "\n",
    "In this section, you’ll use the valuations for the cryptocurrency wallet and for the stock and bond portions of the portfolio to determine if the credit union member has enough savings to build an emergency fund into their financial plan. To do this, complete the following steps:\n",
    "\n",
    "1. Create a Python list named `savings_data` that has two elements. The first element contains the total value of the cryptocurrency wallet. The second element contains the total value of the stock and bond portions of the portfolio.\n",
    "\n",
    "2. Use the `savings_data` list to create a Pandas DataFrame named `savings_df`, and then display this DataFrame. The function to create the DataFrame should take the following three parameters:\n",
    "\n",
    "    - `savings_data`: Use the list that you just created.\n",
    "\n",
    "    - `columns`: Set this parameter equal to a Python list with a single value called `amount`.\n",
    "\n",
    "    - `index`: Set this parameter equal to a Python list with the values of `crypto` and `stock/bond`.\n",
    "\n",
    "3. Use the `savings_df` DataFrame to plot a pie chart that visualizes the composition of the member’s portfolio. The y-axis of the pie chart uses `amount`. Be sure to add a title.\n",
    "\n",
    "4. Using Python, determine if the current portfolio has enough to create an emergency fund as part of the member’s financial plan. Ideally, an emergency fund should equal to three times the member’s monthly income. To do this, implement the following steps:\n",
    "\n",
    "    1. Create a variable named `emergency_fund_value`, and set it equal to three times the value of the member’s `monthly_income` of $12000. (You set this earlier in Part 1).\n",
    "\n",
    "    2. Create a series of three if statements to determine if the member’s total portfolio is large enough to fund the emergency portfolio:\n",
    "\n",
    "        1. If the total portfolio value is greater than the emergency fund value, display a message congratulating the member for having enough money in this fund.\n",
    "\n",
    "        2. Else if the total portfolio value is equal to the emergency fund value, display a message congratulating the member on reaching this important financial goal.\n",
    "\n",
    "        3. Else the total portfolio is less than the emergency fund value, so display a message showing how many dollars away the member is from reaching the goal. (Subtract the total portfolio value from the emergency fund value.)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 1: Create a Python list named `savings_data` that has two elements. The first element contains the total value of the cryptocurrency wallet. The second element contains the total value of the stock and bond portions of the portfolio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[47116.326, 63491.3]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Consolidate financial assets data into a Python list\n",
    "savings_data = [total_crypto_wallet, total_stocks_bonds]\n",
    "\n",
    "# Review the Python list savings_data\n",
    "# YOUR CODE HERE\n",
    "display(savings_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 2: Use the `savings_data` list to create a Pandas DataFrame named `savings_df`, and then display this DataFrame. The function to create the DataFrame should take the following three parameters:\n",
    "\n",
    "- `savings_data`: Use the list that you just created.\n",
    "\n",
    "- `columns`: Set this parameter equal to a Python list with a single value called `amount`.\n",
    "\n",
    "- `index`: Set this parameter equal to a Python list with the values of `crypto` and `stock/bond`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>amount</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>crypto</th>\n",
       "      <td>47116.326</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>stock/bond</th>\n",
       "      <td>63491.300</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               amount\n",
       "crypto      47116.326\n",
       "stock/bond  63491.300"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a Pandas DataFrame called savings_df \n",
    "savings_df = pd.DataFrame(savings_data, columns = [\"amount\"], index=[\"crypto\", \"stock/bond\"])\n",
    "\n",
    "# Display the savings_df DataFrame\n",
    "# YOUR CODE HERE\n",
    "display(savings_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3: Use the `savings_df` DataFrame to plot a pie chart that visualizes the composition of the member’s portfolio. The y-axis of the pie chart uses `amount`. Be sure to add a title."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':\"Member's Portfolio (Crypto and Stock/Bond)\"}, ylabel='amount'>"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the total value of the member's portfolio (crypto and stock/bond) in a pie chart\n",
    "# YOUR CODE HERE\n",
    "savings_df.plot.pie(y='amount', title=\"Member's Portfolio (Crypto and Stock/Bond)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 4: Using Python, determine if the current portfolio has enough to create an emergency fund as part of the member’s financial plan. Ideally, an emergency fund should equal to three times the member’s monthly income. To do this, implement the following steps:\n",
    "\n",
    "Step 1. Create a variable named `emergency_fund_value`, and set it equal to three times the value of the member’s `monthly_income` of 12000. (You set this earlier in Part 1).\n",
    "\n",
    "Step 2. Create a series of three if statements to determine if the member’s total portfolio is large enough to fund the emergency portfolio:\n",
    "\n",
    "* If the total portfolio value is greater than the emergency fund value, display a message congratulating the member for having enough money in this fund.\n",
    "\n",
    "* Else if the total portfolio value is equal to the emergency fund value, display a message congratulating the member on reaching this important financial goal.\n",
    "\n",
    "* Else the total portfolio is less than the emergency fund value, so display a message showing how many dollars away the member is from reaching the goal. (Subtract the total portfolio value from the emergency fund value.)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 4-1: Create a variable named `emergency_fund_value`, and set it equal to three times the value of the member’s `monthly_income` of 12000. (You set this earlier in Part 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36000"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a variable named emergency_fund_value\n",
    "# YOUR CODE HERE\n",
    "emergency_fund_value = 3 * monthly_income\n",
    "display(emergency_fund_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 4-2: Create a series of three if statements to determine if the member’s total portfolio is large enough to fund the emergency portfolio:\n",
    "\n",
    "* If the total portfolio value is greater than the emergency fund value, display a message congratulating the member for having enough money in this fund.\n",
    "\n",
    "* Else if the total portfolio value is equal to the emergency fund value, display a message congratulating the member on reaching this important financial goal.\n",
    "\n",
    "* Else the total portfolio is less than the emergency fund value, so display a message showing how many dollars away the member is from reaching the goal. (Subtract the total portfolio value from the emergency fund value.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Congratulations! You have enough money in this fund.\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the possibility of creating an emergency fund with 3 conditions:\n",
    "# YOUR CODE HERE\n",
    "if total_portfolio > emergency_fund_value:\n",
    "    print(\"Congratulations! You have enough money in this fund.\")\n",
    "\n",
    "# YOUR CODE HERE\n",
    "elif total_portfolio == emergency_fund_value:\n",
    "    print(\"Congratulations! You have reached your financial goal of having an emergency fund.\")\n",
    "\n",
    "# YOUR CODE HERE\n",
    "else:\n",
    "    print(f'Sorry, you are ${emergency_fund_value - total_portfolio} USD away from reaching the goal of having an emergency fund.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Create a Financial Planner for Retirement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the Monte Carlo Simulation\n",
    "\n",
    "In this section, you’ll use the MCForecastTools library to create a Monte Carlo simulation for the member’s savings portfolio. To do this, complete the following steps:\n",
    "\n",
    "1. Make an API call via the Alpaca SDK to get 3 years of historical closing prices for a traditional 60/40 portfolio split: 60% stocks (SPY) and 40% bonds (AGG).\n",
    "\n",
    "2. Run a Monte Carlo simulation of 500 samples and 30 years for the 60/40 portfolio, and then plot the results.The following image shows the overlay line plot resulting from a simulation with these characteristics. However, because a random number generator is used to run each live Monte Carlo simulation, your image will differ slightly from this exact image:\n",
    "\n",
    "![A screenshot depicts the resulting plot.](Images/5-4-monte-carlo-line-plot.png)\n",
    "\n",
    "3. Plot the probability distribution of the Monte Carlo simulation. Plot the probability distribution of the Monte Carlo simulation. The following image shows the histogram plot resulting from a simulation with these characteristics. However, because a random number generator is used to run each live Monte Carlo simulation, your image will differ slightly from this exact image:\n",
    "\n",
    "![A screenshot depicts the histogram plot.](Images/5-4-monte-carlo-histogram.png)\n",
    "\n",
    "4. Generate the summary statistics for the Monte Carlo simulation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 1: Make an API call via the Alpaca SDK to get 3 years of historical closing prices for a traditional 60/40 portfolio split: 60% stocks (SPY) and 40% bonds (AGG)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set start and end dates of 3 years back from your current date\n",
    "# Alternatively, you can use an end date of 2020-08-07 and work 3 years back from that date \n",
    "# YOUR CODE HERE\n",
    "start_date = pd.Timestamp(\"2017-08-07\", tz = \"America/New_York\").isoformat()\n",
    "\n",
    "# YOUR CODE HERE\n",
    "end_date = pd.Timestamp(\"2020-08-07\", tz = \"America/New_York\").isoformat()\n",
    "\n",
    "# Set number of rows to 1000 to retrieve the maximum amount of rows\n",
    "# YOUR CODE HERE\n",
    "limit_rows = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"7\" halign=\"left\">AGG</th>\n",
       "      <th colspan=\"7\" halign=\"left\">SPY</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</th>\n",
       "      <th>trade_count</th>\n",
       "      <th>vwap</th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</th>\n",
       "      <th>trade_count</th>\n",
       "      <th>vwap</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>timestamp</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-08-03 04:00:00+00:00</th>\n",
       "      <td>119.37</td>\n",
       "      <td>119.40</td>\n",
       "      <td>119.1903</td>\n",
       "      <td>119.40</td>\n",
       "      <td>13014535</td>\n",
       "      <td>36359</td>\n",
       "      <td>119.282420</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-08-04 04:00:00+00:00</th>\n",
       "      <td>119.42</td>\n",
       "      <td>119.63</td>\n",
       "      <td>119.4200</td>\n",
       "      <td>119.63</td>\n",
       "      <td>10935181</td>\n",
       "      <td>39114</td>\n",
       "      <td>119.541666</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-08-05 04:00:00+00:00</th>\n",
       "      <td>119.39</td>\n",
       "      <td>119.49</td>\n",
       "      <td>119.3100</td>\n",
       "      <td>119.40</td>\n",
       "      <td>17377874</td>\n",
       "      <td>42313</td>\n",
       "      <td>119.387245</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-08-06 04:00:00+00:00</th>\n",
       "      <td>119.62</td>\n",
       "      <td>119.73</td>\n",
       "      <td>119.5300</td>\n",
       "      <td>119.57</td>\n",
       "      <td>4608710</td>\n",
       "      <td>15938</td>\n",
       "      <td>119.604199</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-08-07 04:00:00+00:00</th>\n",
       "      <td>119.66</td>\n",
       "      <td>119.73</td>\n",
       "      <td>119.3950</td>\n",
       "      <td>119.43</td>\n",
       "      <td>5559066</td>\n",
       "      <td>15246</td>\n",
       "      <td>119.475306</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                              AGG                                      \\\n",
       "                             open    high       low   close    volume   \n",
       "timestamp                                                               \n",
       "2020-08-03 04:00:00+00:00  119.37  119.40  119.1903  119.40  13014535   \n",
       "2020-08-04 04:00:00+00:00  119.42  119.63  119.4200  119.63  10935181   \n",
       "2020-08-05 04:00:00+00:00  119.39  119.49  119.3100  119.40  17377874   \n",
       "2020-08-06 04:00:00+00:00  119.62  119.73  119.5300  119.57   4608710   \n",
       "2020-08-07 04:00:00+00:00  119.66  119.73  119.3950  119.43   5559066   \n",
       "\n",
       "                                                   SPY                        \\\n",
       "                          trade_count        vwap open high low close volume   \n",
       "timestamp                                                                      \n",
       "2020-08-03 04:00:00+00:00       36359  119.282420  NaN  NaN NaN   NaN    NaN   \n",
       "2020-08-04 04:00:00+00:00       39114  119.541666  NaN  NaN NaN   NaN    NaN   \n",
       "2020-08-05 04:00:00+00:00       42313  119.387245  NaN  NaN NaN   NaN    NaN   \n",
       "2020-08-06 04:00:00+00:00       15938  119.604199  NaN  NaN NaN   NaN    NaN   \n",
       "2020-08-07 04:00:00+00:00       15246  119.475306  NaN  NaN NaN   NaN    NaN   \n",
       "\n",
       "                                            \n",
       "                          trade_count vwap  \n",
       "timestamp                                   \n",
       "2020-08-03 04:00:00+00:00         NaN  NaN  \n",
       "2020-08-04 04:00:00+00:00         NaN  NaN  \n",
       "2020-08-05 04:00:00+00:00         NaN  NaN  \n",
       "2020-08-06 04:00:00+00:00         NaN  NaN  \n",
       "2020-08-07 04:00:00+00:00         NaN  NaN  "
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the Alpaca get_bars function to make the API call to get the 3 years worth of pricing data\n",
    "# The tickers and timeframe parameters should have been set in Part 1 of this activity \n",
    "# The start and end dates should be updated with the information set above\n",
    "# Remember to add the df property to the end of the call so the response is returned as a DataFrame\n",
    "# YOUR CODE HERE\n",
    "prices_df = alpaca.get_bars(\n",
    "    tickers,\n",
    "    timeframe,\n",
    "    start = start_date,\n",
    "    end = end_date,\n",
    "    limit = limit_rows\n",
    ").df\n",
    "\n",
    "# Reorganize the DataFrame\n",
    "# Separate ticker data\n",
    "# YOUR CODE HERE\n",
    "agg_df = prices_df[prices_df[\"symbol\"] == \"AGG\"].drop(\"symbol\", axis = 1)\n",
    "spy_df = prices_df[prices_df[\"symbol\"] == \"SPY\"].drop(\"symbol\", axis = 1)\n",
    "\n",
    "# Concatenate the ticker DataFrames\n",
    "# YOUR CODE HERE\n",
    "prices_df = pd.concat([agg_df,spy_df], axis=1, keys=tickers)\n",
    "\n",
    "# Display both the first and last five rows of the DataFrame\n",
    "# YOUR CODE HERE\n",
    "# YOUR CODE HERE\n",
    "prices_df.head()\n",
    "prices_df.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 2: Run a Monte Carlo simulation of 500 samples and 30 years for the 60/40 portfolio, and then plot the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"8\" halign=\"left\">AGG</th>\n",
       "      <th colspan=\"8\" halign=\"left\">SPY</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</th>\n",
       "      <th>trade_count</th>\n",
       "      <th>vwap</th>\n",
       "      <th>daily_return</th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</th>\n",
       "      <th>trade_count</th>\n",
       "      <th>vwap</th>\n",
       "      <th>daily_return</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>timestamp</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-08-07 04:00:00+00:00</th>\n",
       "      <td>109.69</td>\n",
       "      <td>109.72</td>\n",
       "      <td>109.6066</td>\n",
       "      <td>109.67</td>\n",
       "      <td>2359826</td>\n",
       "      <td>7755</td>\n",
       "      <td>109.674876</td>\n",
       "      <td>NaN</td>\n",
       "      <td>247.50</td>\n",
       "      <td>247.87</td>\n",
       "      <td>247.37</td>\n",
       "      <td>247.87</td>\n",
       "      <td>31995021.0</td>\n",
       "      <td>100111.0</td>\n",
       "      <td>247.668698</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-08-08 04:00:00+00:00</th>\n",
       "      <td>109.67</td>\n",
       "      <td>109.69</td>\n",
       "      <td>109.5000</td>\n",
       "      <td>109.57</td>\n",
       "      <td>2570876</td>\n",
       "      <td>12663</td>\n",
       "      <td>109.577636</td>\n",
       "      <td>-0.000912</td>\n",
       "      <td>247.49</td>\n",
       "      <td>248.91</td>\n",
       "      <td>246.83</td>\n",
       "      <td>247.26</td>\n",
       "      <td>61719353.0</td>\n",
       "      <td>192921.0</td>\n",
       "      <td>247.739709</td>\n",
       "      <td>-0.002461</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-08-09 04:00:00+00:00</th>\n",
       "      <td>109.87</td>\n",
       "      <td>109.87</td>\n",
       "      <td>109.6600</td>\n",
       "      <td>109.67</td>\n",
       "      <td>2308932</td>\n",
       "      <td>11031</td>\n",
       "      <td>109.771749</td>\n",
       "      <td>0.000913</td>\n",
       "      <td>246.46</td>\n",
       "      <td>247.31</td>\n",
       "      <td>246.06</td>\n",
       "      <td>247.25</td>\n",
       "      <td>62632619.0</td>\n",
       "      <td>223650.0</td>\n",
       "      <td>246.791421</td>\n",
       "      <td>-0.000040</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-08-10 04:00:00+00:00</th>\n",
       "      <td>109.70</td>\n",
       "      <td>109.85</td>\n",
       "      <td>109.6700</td>\n",
       "      <td>109.78</td>\n",
       "      <td>2004163</td>\n",
       "      <td>12437</td>\n",
       "      <td>109.776611</td>\n",
       "      <td>0.001003</td>\n",
       "      <td>246.30</td>\n",
       "      <td>246.44</td>\n",
       "      <td>243.70</td>\n",
       "      <td>243.76</td>\n",
       "      <td>120418270.0</td>\n",
       "      <td>424321.0</td>\n",
       "      <td>245.027847</td>\n",
       "      <td>-0.014115</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-08-11 04:00:00+00:00</th>\n",
       "      <td>109.75</td>\n",
       "      <td>109.94</td>\n",
       "      <td>109.6800</td>\n",
       "      <td>109.87</td>\n",
       "      <td>1913253</td>\n",
       "      <td>10113</td>\n",
       "      <td>109.860974</td>\n",
       "      <td>0.000820</td>\n",
       "      <td>244.00</td>\n",
       "      <td>244.80</td>\n",
       "      <td>243.75</td>\n",
       "      <td>244.12</td>\n",
       "      <td>74869947.0</td>\n",
       "      <td>278786.0</td>\n",
       "      <td>244.222867</td>\n",
       "      <td>0.001477</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                              AGG                                     \\\n",
       "                             open    high       low   close   volume   \n",
       "timestamp                                                              \n",
       "2017-08-07 04:00:00+00:00  109.69  109.72  109.6066  109.67  2359826   \n",
       "2017-08-08 04:00:00+00:00  109.67  109.69  109.5000  109.57  2570876   \n",
       "2017-08-09 04:00:00+00:00  109.87  109.87  109.6600  109.67  2308932   \n",
       "2017-08-10 04:00:00+00:00  109.70  109.85  109.6700  109.78  2004163   \n",
       "2017-08-11 04:00:00+00:00  109.75  109.94  109.6800  109.87  1913253   \n",
       "\n",
       "                                                                   SPY  \\\n",
       "                          trade_count        vwap daily_return    open   \n",
       "timestamp                                                                \n",
       "2017-08-07 04:00:00+00:00        7755  109.674876          NaN  247.50   \n",
       "2017-08-08 04:00:00+00:00       12663  109.577636    -0.000912  247.49   \n",
       "2017-08-09 04:00:00+00:00       11031  109.771749     0.000913  246.46   \n",
       "2017-08-10 04:00:00+00:00       12437  109.776611     0.001003  246.30   \n",
       "2017-08-11 04:00:00+00:00       10113  109.860974     0.000820  244.00   \n",
       "\n",
       "                                                                            \\\n",
       "                             high     low   close       volume trade_count   \n",
       "timestamp                                                                    \n",
       "2017-08-07 04:00:00+00:00  247.87  247.37  247.87   31995021.0    100111.0   \n",
       "2017-08-08 04:00:00+00:00  248.91  246.83  247.26   61719353.0    192921.0   \n",
       "2017-08-09 04:00:00+00:00  247.31  246.06  247.25   62632619.0    223650.0   \n",
       "2017-08-10 04:00:00+00:00  246.44  243.70  243.76  120418270.0    424321.0   \n",
       "2017-08-11 04:00:00+00:00  244.80  243.75  244.12   74869947.0    278786.0   \n",
       "\n",
       "                                                    \n",
       "                                 vwap daily_return  \n",
       "timestamp                                           \n",
       "2017-08-07 04:00:00+00:00  247.668698          NaN  \n",
       "2017-08-08 04:00:00+00:00  247.739709    -0.002461  \n",
       "2017-08-09 04:00:00+00:00  246.791421    -0.000040  \n",
       "2017-08-10 04:00:00+00:00  245.027847    -0.014115  \n",
       "2017-08-11 04:00:00+00:00  244.222867     0.001477  "
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Configure the Monte Carlo simulation to forecast 30 years cumulative returns\n",
    "# The weights should be split 40% to AGG and 60% to SPY.\n",
    "# Run 500 samples.\n",
    "# YOUR CODE HERE\n",
    "mc_30_years = MCSimulation(\n",
    "    portfolio_data = prices_df,\n",
    "    num_trading_days = 252 * 30,\n",
    "    weights = [.40, .60],\n",
    "    num_simulation = 500\n",
    ")\n",
    "\n",
    "# Review the simulation input data\n",
    "# YOUR CODE HERE\n",
    "mc_30_years.portfolio_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 0.\n",
      "Running Monte Carlo simulation number 10.\n",
      "Running Monte Carlo simulation number 20.\n",
      "Running Monte Carlo simulation number 30.\n",
      "Running Monte Carlo simulation number 40.\n",
      "Running Monte Carlo simulation number 50.\n",
      "Running Monte Carlo simulation number 60.\n",
      "Running Monte Carlo simulation number 70.\n",
      "Running Monte Carlo simulation number 80.\n",
      "Running Monte Carlo simulation number 90.\n",
      "Running Monte Carlo simulation number 100.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 110.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 120.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 130.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 140.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 150.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 160.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 170.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 180.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 190.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 200.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 210.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 220.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 230.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 240.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 250.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 260.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 270.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 280.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 290.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 300.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 310.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 320.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 330.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 340.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 350.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 360.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 370.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 380.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 390.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 400.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 410.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 420.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 430.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 440.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 450.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 460.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 470.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 480.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 490.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>...</th>\n",
       "      <th>490</th>\n",
       "      <th>491</th>\n",
       "      <th>492</th>\n",
       "      <th>493</th>\n",
       "      <th>494</th>\n",
       "      <th>495</th>\n",
       "      <th>496</th>\n",
       "      <th>497</th>\n",
       "      <th>498</th>\n",
       "      <th>499</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7556</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7557</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7558</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7559</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7560</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>7561 rows × 500 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      0    1    2    3    4    5    6    7    8    9    ...  490  491  492  \\\n",
       "0     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "1     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "2     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "3     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "4     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "...   ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...   \n",
       "7556  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "7557  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "7558  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "7559  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "7560  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "\n",
       "      493  494  495  496  497  498  499  \n",
       "0     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "1     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "2     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "3     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "4     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "...   ...  ...  ...  ...  ...  ...  ...  \n",
       "7556  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "7557  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "7558  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "7559  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "7560  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "\n",
       "[7561 rows x 500 columns]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the Monte Carlo simulation to forecast 30 years cumulative returns\n",
    "# YOUR CODE HERE\n",
    "mc_30_years.calc_cumulative_return()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the 30-year Monte Carlo simulation by creating an\n",
    "# overlay line plot\n",
    "# YOUR CODE HERE\n",
    "mc_plot = mc_30_years.plot_simulation()\n",
    "\n",
    "\n",
    "# I could not draw the plot of the simulation, I guess it is because while running the simulation I got a bunch of these messages below:\n",
    "#C:\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
    "#  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3: Plot the probability distribution of the Monte Carlo simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAAEICAYAAADlbAsQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAck0lEQVR4nO3deZwcVb3+8c9DAhcCgQAJSAIhIIssl83ghsrqwu6CyL5cNXJRBMHLoiioF8X7uygiICJyI7vIJigocLmAymbAsAYEWUOAJEBIWEPg+/vjnCaVSc9Mz3Sn+0zyvF+veU13V/Wpb1VX1VOnqqZHEYGZmVmJFut0AWZmZt1xSJmZWbEcUmZmViyHlJmZFcshZWZmxXJImZlZsVoSUpLOkPTtFrU1WtLLkgbl5zdK+mIr2s7tXSNp/1a114fp/qek6ZKe7cN79pZ0bYum/7ik7VrR1oIkaStJkxdg+y9LWnNBtW/lqO47JB0g6S+drqk3ku6XtNUCaHeMpJA0uJ/v/6aks1pdVyN6Dam8c3tN0ixJMyTdIukgSe+8NyIOiojvN9hWjzvKiHgyIpaJiLcam4Uep3e8pPO6tL99RPy62bb7WMdqwBHA+hHxrjrDt5L0dt6B1n6uiojzI+LjbarxfZKuzp/xC5LukHRgO6a9oNQ7wMnr1qMtnk7185sl6aFGl12zO48FQdLSeV6u7nQtvVHyqKQHmmwnJL1S2f7O6jL865KelfSSpLMl/Utl2AqSLs/vf0LSXj1MZwlJJ0manKfzmKSf1IZHxAYRcWMz89KsegeKEfGDiGhZZ6EvGu1J7RwRQ4HVgROBo4BftbqYkjbUFlsdeD4ipvYwzpS8A6397Nyu4iR9ELgBuAlYC1gR+Hdg+3bVsBCYEhHLAMsCXwd+KWndBT3RvJNu9Wn73YA3gI9LWqU/DdTOhLTBR4GVgDUlbd5kWxtXtr93dsiSPgEcDWwLjAHWBL5bed9pwGxgZWBv4OeSNuhmGscAY4H3AUOBrYG/N1n3wi0ievwBHge26/La+4C3gQ3z8/HAf+bHw4HfAzOAF4A/k8Lw3Pye14CXgSNJH3gAXwCeBG6uvDY4t3cj8EPgDuAl4HfACnnYVsDkevUCnyStOG/m6d1dae+L+fFiwLHAE8BU4BxguTysVsf+ubbpwLd6WE7L5fdPy+0dm9vfLs/z27mO8XXeO9985NcPAP5SeR7AQcDDwIukjUN52LtJQfN8rvV8YFhPn2Nl2F+A03qYt3nqqNSyVuXzPx24Js/jX4F3ASfnOh8ENq333jrrzzzLopdxlyeta9PydH4PrJqHnQC8Bbyeazq12h7wAeBZYFCl7U8D91TWjaOBf+ZlejF5vWvk88vr0+d6ayuvW5FrfBn4IHA8cF6lrTHMv02ckJfza3l+elo31iIdgLyU143f9LLN35Dbvwv4RpdhHwZuIW3fTwEHVD6XnwNXA6+Q1vv1cq0zgPuBXSrt7AA8AMwCnq5Nh272Hz3UejZpXb+s9hlXht3I3G39ALqsw92tz3WGXQD8oPJ8W+DZ/Hhp0n5mncrwc4ETu2nr98Bhjexv83rwW+C8vJzuBdYhBd3UvPw/3t02Xl2P6qxDBwKTcruPAl+uzE91f/UyMJL518ld8mc6Iy/n9brU8Q3gHtI69xtgyf58vhHRv2tSEXEHMBn4SJ3BR+RhI0hHFt9Mb4l9SRvkzpGOVP6r8p4tSSv0J7qZ5H7Av5EW1hzglAZq/CPwA9IGuUxEbFxntAPyz9ako6NlgFO7jPNhYF3SivkdSet1M8mfkYJqzTw/+wEHRsT1pB5Jrad0QG+192InYHNgY2B35i4zkcJ8JGlZrkZasXokaQhpx3hJk3XtTgrm4aSj8FtJO7nhue0fN9l+PYsB/0PqqY4mbVynAkTEt0gbwFfzcv9q9Y0RcRtpZ7pN5eW9SDskgK8BnyJ9liOZu+PvkaTFJO1Cmu9HGmjro/n3sFznrQ3MN8C+wDjS0fgT+bXu1o3vA9eSQn1V0rraXf2jSaF7fv7Zr8uwa/L7RwCbABMrb9+LFG5DgduBq/J0VwIOAc6v9C5/RdoxDgU2JAUjdLP/6KbWIaReX63WPSQt0d28NeDmfErvMkljKq9vANxdeX43sLKkFUmh8VZE/KPL8O56UrcBh0s6WNK/SlIvNe1MCr3lST2uP5HW+1HA94BfNDZr85lKWl+WJQXWTyRtFhGvMO/+apmImFJ9o6R1gAuBw0if09XAVV2W/e6kjsIawEak/Sz04fOtaeY0wRRghTqvvwmsAqweEW9GxJ8jR2gPjo+IVyLitW6GnxsR9+UF+G1g9xadTtgb+HFEPBoRL5OOUPboctrxuxHxWkTcTVr55gu7XMvngWMiYlZEPA6cRNqRNGpkvh5U+9m9m/FOjIgZEfEk8H+kHQUR8UhEXBcRb0TENFIobNnAdJcnrQfP9KHWei6PiDsj4nXgcuD1iDgn0rXF3wCbNtn+fCLi+Yi4NCJejYhZpB1kI/NccyGwJ4CkoaSj+wvzsC+Tes6TI+INUuDv1sMp6ZGSZpCC8nLg8Iioncbpa1uNGB8R90fEnIh4M79Wd90gbZOrAyMj4vWI6OkGgv1IvckHSMtiA0m1z25v4PqIuDBv289HxMTKe38XEX+NiLfztJfJNc2OiBtIR9B7VmpaX9KyEfFiRNxVeb3R/cdnSAdE1+a2BwM79jBvPdmS1Nt4D2nf9vvK57MMqUdQU3s8tM6w2vCh3Uznh8CPSMtyAvC0er6R688R8aeImEPqVY0gLdM3gYuAMZKG9Tp3XUTEHyLin5HcRFqG9Tod9Xwe+EPe37wJ/DewFPChyjinRMSUiHiBdLCySX69z/nQTEiNInXXuvp/pCPIa/MFzaMbaOupPgx/AlicdKTarJHMPQqttT2YlPA11bvxXiWtlF0NB5ao09aoPtQyJSKGVX4u7ma8uvVIWknSRZKeljSTdIqgkWX0Iqlr369rDxXPVR6/Vud5veXWFElDJP0iX6yeSTpdPKwPBzAXAJ/JF8E/A9wVEbXPcHXg8tpBA+nUyFvMu25UTYmIYaQj01OYt4fW17YaUW+b6W5dPZLU075D6e6xf+uh3f1IvRLyEfRNpFPekHrn/2ywppHAUzmwaqrbxGdJBwVPSLopXxeFvu0/9gcuzkH9BumUX7/u3I2Im3OYzgAOJfUAamdNXiZ9rjW1x7PqDKsNn9XNdN6KiNMiYgtgGOnA6uweztB03Y6mx9ybymoH9X3etiRtL+m2fJPUDNJn0eg+dZ79Zv6Mn2Le/V1362Kf86FfIZUvUI4iXcuYR+5JHBERa5K6qodL2rY2uJsme+tprVZ5PJqUxtNJp2uGVOoaRDrSaLTdKaQdSLXtOcy7YjRiOnOPVqttPd3HdprxQ9L8bhQRywL7kHZMPYqIV0mn5j7bw2hdl/N8dyj20avV9kjXr/oz7hGkU7Hvz/NcO3VWm+8eP//cW3iCdHqjeqoP0ka3fZcDhyUjosfPNO8sjwL+VdKnGmirXo3zLG/qL5/e1u1qTc9GxJciYiSpV3e6pLW6jifpQ8DawDH5tNezwPuBPXOv4inStc9uJ1V5PAVYrctNHe9sExHxt4jYlXQq8ArSdbre9h/VWlclHQjsU6l1N2AHSa04gA3mrkf3M+8ZlI2B5yLieeAfwGBJa3cZfn+vE0hnaE4jHSiu34KaG1lvyAdll5J6QCvng6uraXC7oct+M5+yXI0G9neNfr5VfQopSctK2onUzTwvIu6tM85OktbKhc8kHTHWkv850jWbvtpH0vr5HPT3gEvy0cQ/gCUl7ShpcdI1kX+pvO85Une4u/m8EPi6pDUkLcPca1hz+lJcruVi4ARJQyWtDhxO6s20y1DSUd0MSaOA/+jDe48EDpD0H/k8O5I2lnRRHn436bTPJpKWpIFrXb2YCOwlaZCkT9LzKbqexh1KOpqcIWkF4Lgu721kfbuAdM3oo6TTKTVnkD7P1QEkjZC0ay9tARARs0mne7/TQFvTSD3Zap0TgY8q/c3gcqTT0P0m6XN5pw5phxjM3Sar9geuI+0wN8k/G5J2fNuTeljbSdpd0mBJK0rapJvJ3k7aaR4paXGlv/3ZGbhI6TbsvSUtl08X1fYTve0/qvYlbf/rVmpdh3S9Y88643dLUm3dHpT3AyeRdriT8ijnAF/I+6DlSfuZ8QD5EsRlwPeUbt3fAtiVdB2p3rQOU7rFe6m8DPcnrcd/rzd+H00kXa5YXNJYUmjXswRpPzkNmCNpe6D6py7PASvmda+ei4EdJW2b97tHkE673tJbgX34fN/RaEhdJWkW6UjqW6TrHd39HcjawPWkHeatwOkx977/HwLH5tMe32hw2pA+8PGkLuSSpJ0KEfEScDBwFmmleoW0ktbUdjrPS7qL+Z2d274ZeIx0J9ghfair6pA8/UdJPcwLcvvt8l1gM9L58D+QNpyGRMQtpKPSbYBHJb0AnEk6uiLSReHvkT7Xh6nTg+6jQ0k7rBmkc/NX9HPck0nnwqeTLkj/sct7f0q69vOipO5utrmQdKPADRExvct7rySdlpiV239/TzPVxdnAaEk799RW7smeAPw1bxcfiIjrSNfx7gHuJF1vacbmwO2SXs51HBoRj1VHyAcfuwM/yz2v2s9jpG1k/3ytawfSTukF0k6x3g1JtaDehRRu00l3f+4XEQ/mUfYFHlc6TXsQqecPPe8/qvbPw6q1Pks6IOjrKb+VSct7Jmn7HQPsVLvWF+kmrP8iXed7Iv9UD4gOJq2HU0nr079HRHc9qddIIfgsabl8BfhstOZv975N6um+SNofXFBvpEjXb79GCpsXSWcRrqwMfzDPx6N5nRzZ5f0PkT6vn+V52Jl0Q9zsBmps9PN9R+0WVTMzs+L4u/vMzKxYDikzMyuWQ8rMzIrlkDIzs2INyC90HT58eIwZM6bTZZjNb+LE9HuTTTpZhVldd9555/SIGNH7mOUYkCE1ZswYJkyY0OkyzOY3bFj67fXTCiTpid7HKotP95mZWbEcUmZmViyHlJmZFcshZWZmxXJImZlZsRxSZmZWrLaGlKSzJU2VdF/ltRUkXSfp4fx7+XbWZGZm5Wp3T2o86f/eVx0N/G9ErA38b35uZmbW3pCKiJuZ/1/O7wr8Oj/+NfCpdtZkZmblKuEbJ1aOiGcAIuIZSSvVG0nSOGAcwOjRo9tYnlnfzHz9TTY6+g9tn+7jJ+7Y9mmaLWgD5saJiDgzIsZGxNgRIwbUV0+ZmVk/lRBSz0laBSD/ntrheszMrBAlhNSVwP758f7A7zpYi5mZFaTdt6BfCNwKrCtpsqQvACcCH5P0MPCx/NzMzKy9N05ExJ7dDNq2nXWYmdnAUMLpPjMzs7ocUmZmViyHlJmZFcshZWZmxXJImZlZsRxSZmZWLIeUmZkVyyFlZmbFckiZmVmxHFJmZlYsh5SZmRXLIWVmZsVySJmZWbEcUmZmViyHlJmZFcshZWZmxXJImZlZsRxSZmZWLIeUmZkVyyFlZmbFckiZmVmxHFJmZlYsh5SZmRXLIWVmZsVySJmZWbEcUmZmViyHlJmZFcshZWZmxXJImZlZsRxSZmZWLIeUmZkVyyFlZmbFKiakJH1d0v2S7pN0oaQlO12TmZl1VhEhJWkU8DVgbERsCAwC9uhsVWZm1mlFhFQ2GFhK0mBgCDClw/WYmVmHFRFSEfE08N/Ak8AzwEsRcW11HEnjJE2QNGHatGmdKNPMzNqsiJCStDywK7AGMBJYWtI+1XEi4syIGBsRY0eMGNGJMs3MrM2KCClgO+CxiJgWEW8ClwEf6nBNZmbWYaWE1JPAByQNkSRgW2BSh2syM7MOKyKkIuJ24BLgLuBeUl1ndrQoMzPruMGdLqAmIo4Djut0HWZmVo4ielJmZmb1OKTMzKxYDikzMyuWQ8rMzIrlkDIzs2I5pMzMrFgOKTMzK5ZDyszMiuWQMjOzYjmkzMysWA4pMzMrlkPKzMyK5ZAyM7NiOaTMzKxYDikzMyuWQ8rMzIrlkDIzs2I5pMzMrFgOKTMzK5ZDyszMiuWQMjOzYjmkzMysWA4pMzMrlkPKzMyK5ZAyM7NiOaTMzKxYDikzMyuWQ8rMzIrV75CStGErCzEzM+uqmZ7UGZLukHSwpGGtKsjMzKym3yEVER8G9gZWAyZIukDSx1pWmZmZLfKauiYVEQ8DxwJHAVsCp0h6UNJnWlGcmZkt2pq5JrWRpJ8Ak4BtgJ0jYr38+Cf9aG+YpEtyyE2S9MH+1mZmZguHwU2891Tgl8A3I+K12osRMUXSsf1o76fAHyNiN0lLAEOaqM3MzBYCzYTUDsBrEfEWgKTFgCUj4tWIOLcvDUlaFvgocABARMwGZjdRm5mZLQSauSZ1PbBU5fmQ/Fp/rAlMA/5H0t8lnSVp6SZqMzOzhUAzIbVkRLxce5If9/cU3WBgM+DnEbEp8ApwdHUESeMkTZA0Ydq0af2t2czMBpBmQuoVSZvVnkh6L/BaD+P3ZDIwOSJuz88vIYXWOyLizIgYGxFjR4wY0c/JmJnZQNLMNanDgN9KmpKfrwJ8vj8NRcSzkp6StG5EPARsCzzQRG1mZrYQ6HdIRcTfJL0HWBcQ8GBEvNlELYcA5+c7+x4FDmyiLTMzWwg005MC2BwYk9vZVBIRcU5/GoqIicDYJusxM7OFSL9DStK5wLuBicBb+eUA+hVSZmZmXTXTkxoLrB8R0apizMzMqpq5u+8+4F2tKsTMzKyrZnpSw4EHJN0BvFF7MSJ2aboqMzMzmgup41tVhJmZWT3N3IJ+k6TVgbUj4npJQ4BBrSvNzMwWdc38q44vkb4Z4hf5pVHAFS2oyczMDGjuxomvAFsAM+Gdf4C4UiuKMjMzg+ZC6o38LzUAkDSY9HdSZmZmLdFMSN0k6ZvAUpI+BvwWuKo1ZZmZmTUXUkeT/gfUvcCXgauB/vxHXjMzs7qaubvvbdK/j/9l68oxMzObq5nv7nuMOtegImLNpioyMzPLmv3uvpolgc8BKzRXjpmZ2Vz9viYVEc9Xfp6OiJOBbVpXmpmZLeqaOd1X/ffui5F6VkObrsjMzCxr5nTfSZXHc4DHgd2bqsbMzKyimbv7tm5lIWZmZl01c7rv8J6GR8SP+9u2mZkZNH933+bAlfn5zsDNwFPNFmVmZgbN/9PDzSJiFoCk44HfRsQXW1GYmZlZM1+LNBqYXXk+GxjTVDVmZmYVzfSkzgXukHQ56ZsnPg2c05KqzMzMaO7uvhMkXQN8JL90YET8vTVlmZmZNXe6D2AIMDMifgpMlrRGC2oyMzMDmvv38ccBRwHH5JcWB85rRVFmZmbQXE/q08AuwCsAETEFfy2SmZm1UDMhNTsigvzvOiQt3ZqSzMzMkmZC6mJJvwCGSfoScD3+B4hmZtZC/bq7T5KA3wDvAWYC6wLfiYjrWlibmZkt4voVUhERkq6IiPcCDiYzM1sgmjndd5ukzVtWiZmZWRfNfOPE1sBBkh4n3eEnUidro1YUZmZm1ueQkjQ6Ip4Etm9lIZIGAROApyNip1a2bWZmA1N/elJXkL79/AlJl0bEZ1tUy6HAJGDZFrVnZmYDXH+uSanyeM1WFCFpVWBH4KxWtGdmZguH/oRUdPO4GScDRwJvdzeCpHGSJkiaMG3atBZN1szMStafkNpY0kxJs4CN8uOZkmZJmtnXxiTtBEyNiDt7Gi8izoyIsRExdsSIEf0o28zMBpo+X5OKiEEtrmELYBdJOwBLAstKOi8i9mnxdMzMbIBp9l91NC0ijomIVSNiDLAHcIMDyszMoICQMjMz604zf8zbchFxI3Bjh8swM7NCuCdlZmbFckiZmVmxHFJmZlYsh5SZmRXLIWVmZsVySJmZWbEcUmZmViyHlJmZFcshZWZmxXJImZlZsRxSZmZWLIeUmZkVyyFlZmbFckiZmVmxHFJmZlYsh5SZmRXLIWVmZsVySJmZWbEcUmZmViyHlJmZFcshZWZmxXJImZlZsRxSZmZWLIeUmZkVyyFlZmbFckiZmVmxHFJmZlYsh5SZmRXLIWVmZsVySJmZWbEcUmZmViyHlJmZFauIkJK0mqT/kzRJ0v2SDu10TWZm1nmDO11ANgc4IiLukjQUuFPSdRHxQKcLMzOzzimiJxURz0TEXfnxLGASMKqzVZmZWacVEVJVksYAmwK3d3l9nKQJkiZMmzatI7WZmVl7FRVSkpYBLgUOi4iZ1WERcWZEjI2IsSNGjOhMgWZm1lbFhJSkxUkBdX5EXNbpeszMrPOKCClJAn4FTIqIH3e6HjMzK0MRIQVsAewLbCNpYv7ZodNFmZlZZxVxC3pE/AVQp+swM7OylNKTMjMzm49DyszMiuWQMjOzYjmkzMysWA4pMzMrlkPKzMyK5ZAyM7NiOaTMzKxYDikzMyuWQ8rMzIrlkDIzs2I5pMzMrFgOKTMzK5ZDyszMiuWQMjOzYjmkzMysWA4pMzMrlkPKzMyK5ZAyM7NiOaTMzKxYDikzMyuWQ8rMzIrlkDIzs2I5pMzMrFgOKTMzK5ZDyszMiuWQMjOzYjmkzMysWA4pMzMrlkPKzMyK5ZAyM7NiOaTMzKxYDikzMytWMSEl6ZOSHpL0iKSjO12PmZl1XhEhJWkQcBqwPbA+sKek9TtblZmZdVoRIQW8D3gkIh6NiNnARcCuHa7JzMw6bHCnC8hGAU9Vnk8G3l8dQdI4YFx++rKkh9pUWysNB6Z3uog2WzTn+Uc7tX2e9aN2T3Eei9rnPFDnd/VOF9BXpYSU6rwW8zyJOBM4sz3lLBiSJkTE2E7X0U6e50XDojbPi9r8dlIpp/smA6tVnq8KTOlQLWZmVohSQupvwNqS1pC0BLAHcGWHazIzsw4r4nRfRMyR9FXgT8Ag4OyIuL/DZS0IA/p0ZT95nhcNi9o8L2rz2zGKiN7HMjMz64BSTveZmZnNxyFlZmbFckgtAI18xZOkrSRNlHS/pJvaXWMr9Ta/kpaTdJWku/P8HtiJOltJ0tmSpkq6r5vhknRKXib3SNqs3TW2WgPzvHee13sk3SJp43bX2Gq9zXNlvM0lvSVpt3bVtqhwSLVYI1/xJGkYcDqwS0RsAHyu3XW2SoNfafUV4IGI2BjYCjgp38U5kI0HPtnD8O2BtfPPOODnbahpQRtPz/P8GLBlRGwEfJ+F4+aC8fQ8z7Vt4EekG7+sxRxSrdfIVzztBVwWEU8CRMTUNtfYSo3MbwBDJQlYBngBmNPeMlsrIm4mzUd3dgXOieQ2YJikVdpT3YLR2zxHxC0R8WJ+ehvp7x0HtAY+Z4BDgEuBgbwdF8sh1Xr1vuJpVJdx1gGWl3SjpDsl7de26lqvkfk9FViP9Afa9wKHRsTb7SmvYxpZLguzLwDXdLqIBU3SKODTwBmdrmVhVcTfSS1kev2KJ9Jyfy+wLbAUcKuk2yLiHwu6uAWgkfn9BDAR2AZ4N3CdpD9HxMwFXFsnNbJcFkqStiaF1Ic7XUsbnAwcFRFvpRMF1moOqdZr5CueJgPTI+IV4BVJNwMbAwMxpBqZ3wOBEyP9Ud4jkh4D3gPc0Z4SO2KR/KovSRsBZwHbR8Tzna6nDcYCF+WAGg7sIGlORFzR0aoWIj7d13qNfMXT74CPSBosaQjpG98ntbnOVmlkfp8k9RqRtDKwLvBoW6tsvyuB/fJdfh8AXoqIZzpd1IIkaTRwGbDvAD0r0GcRsUZEjImIMcAlwMEOqNZyT6rFuvuKJ0kH5eFnRMQkSX8E7gHeBs6KiB5vcS1VI/NLutNrvKR7SafBjoqIgfhvDt4h6ULSnYrDJU0GjgMWh3fm+WpgB+AR4FVSb3JAa2CevwOsCJyeexZzBvo3hTcwz7aA+WuRzMysWD7dZ2ZmxXJImZlZsRxSZmZWLIeUmZkVyyFlZmbFckiZmVmxHFJmZlas/w/qgRyn4DZg9wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the probability distribution of the 30-year Monte Carlo simulation \n",
    "# by plotting a histogram\n",
    "# YOUR CODE HERE\n",
    "mc_plot = mc_30_years.plot_distribution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 4: Generate the summary statistics for the Monte Carlo simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:172: FutureWarning: The series.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  return metrics.append(ci_series)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "count           500.0\n",
       "mean              1.0\n",
       "std               0.0\n",
       "min               1.0\n",
       "25%               1.0\n",
       "50%               1.0\n",
       "75%               1.0\n",
       "max               1.0\n",
       "95% CI Lower      1.0\n",
       "95% CI Upper      1.0\n",
       "Name: 7560, dtype: float64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generate summary statistics from the 30-year Monte Carlo simulation results\n",
    "# Save the results as a variable\n",
    "# YOUR CODE HERE\n",
    "mc_summary_statistics = mc_30_years.summarize_cumulative_return()\n",
    "\n",
    "# Review the 30-year Monte Carlo summary statistics\n",
    "# YOUR CODE HERE\n",
    "display(mc_summary_statistics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analyze the Retirement Portfolio Forecasts\n",
    "\n",
    "Using the current value of only the stock and bond portion of the member's portfolio and the summary statistics that you generated from the Monte Carlo simulation, answer the following question in your Jupyter notebook:\n",
    "\n",
    "-  What are the lower and upper bounds for the expected value of the portfolio with a 95% confidence interval?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63491.3\n"
     ]
    }
   ],
   "source": [
    "# Print the current balance of the stock and bond portion of the members portfolio\n",
    "# YOUR CODE HERE\n",
    "print(total_stocks_bonds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your initial investment has a 95% chance of being in the range between $63491.30 USD and $63491.30 USD in the next 30 days.\n"
     ]
    }
   ],
   "source": [
    "# Use the lower and upper `95%` confidence intervals to calculate the range of the possible outcomes for the current stock/bond portfolio\n",
    "ci_lower_thirty_cumulative_return = mc_summary_statistics[8] * total_stocks_bonds\n",
    "ci_upper_thirty_cumulative_return = mc_summary_statistics[9] * total_stocks_bonds\n",
    "\n",
    "# Print the result of your calculations\n",
    "# YOUR CODE HERE\n",
    "print(f\"Your initial investment has a 95% chance of being in the range between ${ci_lower_thirty_cumulative_return:.2f} USD and ${ci_upper_thirty_cumulative_return:.2f} USD in the next 30 days.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forecast Cumulative Returns in 10 Years\n",
    "\n",
    "The CTO of the credit union is impressed with your work on these planning tools but wonders if 30 years is a long time to wait until retirement. So, your next task is to adjust the retirement portfolio and run a new Monte Carlo simulation to find out if the changes will allow members to retire earlier.\n",
    "\n",
    "For this new Monte Carlo simulation, do the following: \n",
    "\n",
    "- Forecast the cumulative returns for 10 years from now. Because of the shortened investment horizon (30 years to 10 years), the portfolio needs to invest more heavily in the riskier asset&mdash;that is, stock&mdash;to help accumulate wealth for retirement. \n",
    "\n",
    "- Adjust the weights of the retirement portfolio so that the composition for the Monte Carlo simulation consists of 20% bonds and 80% stocks. \n",
    "\n",
    "- Run the simulation over 500 samples, and use the same data that the API call to Alpaca generated.\n",
    "\n",
    "- Based on the new Monte Carlo simulation, answer the following questions in your Jupyter notebook:\n",
    "\n",
    "    - Using the current value of only the stock and bond portion of the member's portfolio and the summary statistics that you generated from the new Monte Carlo simulation, what are the lower and upper bounds for the expected value of the portfolio (with the new weights) with a 95% confidence interval?\n",
    "\n",
    "    - Will weighting the portfolio more heavily toward stocks allow the credit union members to retire after only 10 years?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"8\" halign=\"left\">AGG</th>\n",
       "      <th colspan=\"8\" halign=\"left\">SPY</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</th>\n",
       "      <th>trade_count</th>\n",
       "      <th>vwap</th>\n",
       "      <th>daily_return</th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</th>\n",
       "      <th>trade_count</th>\n",
       "      <th>vwap</th>\n",
       "      <th>daily_return</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>timestamp</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-08-07 04:00:00+00:00</th>\n",
       "      <td>109.69</td>\n",
       "      <td>109.72</td>\n",
       "      <td>109.6066</td>\n",
       "      <td>109.67</td>\n",
       "      <td>2359826</td>\n",
       "      <td>7755</td>\n",
       "      <td>109.674876</td>\n",
       "      <td>NaN</td>\n",
       "      <td>247.50</td>\n",
       "      <td>247.87</td>\n",
       "      <td>247.37</td>\n",
       "      <td>247.87</td>\n",
       "      <td>31995021.0</td>\n",
       "      <td>100111.0</td>\n",
       "      <td>247.668698</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-08-08 04:00:00+00:00</th>\n",
       "      <td>109.67</td>\n",
       "      <td>109.69</td>\n",
       "      <td>109.5000</td>\n",
       "      <td>109.57</td>\n",
       "      <td>2570876</td>\n",
       "      <td>12663</td>\n",
       "      <td>109.577636</td>\n",
       "      <td>-0.000912</td>\n",
       "      <td>247.49</td>\n",
       "      <td>248.91</td>\n",
       "      <td>246.83</td>\n",
       "      <td>247.26</td>\n",
       "      <td>61719353.0</td>\n",
       "      <td>192921.0</td>\n",
       "      <td>247.739709</td>\n",
       "      <td>-0.002461</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-08-09 04:00:00+00:00</th>\n",
       "      <td>109.87</td>\n",
       "      <td>109.87</td>\n",
       "      <td>109.6600</td>\n",
       "      <td>109.67</td>\n",
       "      <td>2308932</td>\n",
       "      <td>11031</td>\n",
       "      <td>109.771749</td>\n",
       "      <td>0.000913</td>\n",
       "      <td>246.46</td>\n",
       "      <td>247.31</td>\n",
       "      <td>246.06</td>\n",
       "      <td>247.25</td>\n",
       "      <td>62632619.0</td>\n",
       "      <td>223650.0</td>\n",
       "      <td>246.791421</td>\n",
       "      <td>-0.000040</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-08-10 04:00:00+00:00</th>\n",
       "      <td>109.70</td>\n",
       "      <td>109.85</td>\n",
       "      <td>109.6700</td>\n",
       "      <td>109.78</td>\n",
       "      <td>2004163</td>\n",
       "      <td>12437</td>\n",
       "      <td>109.776611</td>\n",
       "      <td>0.001003</td>\n",
       "      <td>246.30</td>\n",
       "      <td>246.44</td>\n",
       "      <td>243.70</td>\n",
       "      <td>243.76</td>\n",
       "      <td>120418270.0</td>\n",
       "      <td>424321.0</td>\n",
       "      <td>245.027847</td>\n",
       "      <td>-0.014115</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-08-11 04:00:00+00:00</th>\n",
       "      <td>109.75</td>\n",
       "      <td>109.94</td>\n",
       "      <td>109.6800</td>\n",
       "      <td>109.87</td>\n",
       "      <td>1913253</td>\n",
       "      <td>10113</td>\n",
       "      <td>109.860974</td>\n",
       "      <td>0.000820</td>\n",
       "      <td>244.00</td>\n",
       "      <td>244.80</td>\n",
       "      <td>243.75</td>\n",
       "      <td>244.12</td>\n",
       "      <td>74869947.0</td>\n",
       "      <td>278786.0</td>\n",
       "      <td>244.222867</td>\n",
       "      <td>0.001477</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                              AGG                                     \\\n",
       "                             open    high       low   close   volume   \n",
       "timestamp                                                              \n",
       "2017-08-07 04:00:00+00:00  109.69  109.72  109.6066  109.67  2359826   \n",
       "2017-08-08 04:00:00+00:00  109.67  109.69  109.5000  109.57  2570876   \n",
       "2017-08-09 04:00:00+00:00  109.87  109.87  109.6600  109.67  2308932   \n",
       "2017-08-10 04:00:00+00:00  109.70  109.85  109.6700  109.78  2004163   \n",
       "2017-08-11 04:00:00+00:00  109.75  109.94  109.6800  109.87  1913253   \n",
       "\n",
       "                                                                   SPY  \\\n",
       "                          trade_count        vwap daily_return    open   \n",
       "timestamp                                                                \n",
       "2017-08-07 04:00:00+00:00        7755  109.674876          NaN  247.50   \n",
       "2017-08-08 04:00:00+00:00       12663  109.577636    -0.000912  247.49   \n",
       "2017-08-09 04:00:00+00:00       11031  109.771749     0.000913  246.46   \n",
       "2017-08-10 04:00:00+00:00       12437  109.776611     0.001003  246.30   \n",
       "2017-08-11 04:00:00+00:00       10113  109.860974     0.000820  244.00   \n",
       "\n",
       "                                                                            \\\n",
       "                             high     low   close       volume trade_count   \n",
       "timestamp                                                                    \n",
       "2017-08-07 04:00:00+00:00  247.87  247.37  247.87   31995021.0    100111.0   \n",
       "2017-08-08 04:00:00+00:00  248.91  246.83  247.26   61719353.0    192921.0   \n",
       "2017-08-09 04:00:00+00:00  247.31  246.06  247.25   62632619.0    223650.0   \n",
       "2017-08-10 04:00:00+00:00  246.44  243.70  243.76  120418270.0    424321.0   \n",
       "2017-08-11 04:00:00+00:00  244.80  243.75  244.12   74869947.0    278786.0   \n",
       "\n",
       "                                                    \n",
       "                                 vwap daily_return  \n",
       "timestamp                                           \n",
       "2017-08-07 04:00:00+00:00  247.668698          NaN  \n",
       "2017-08-08 04:00:00+00:00  247.739709    -0.002461  \n",
       "2017-08-09 04:00:00+00:00  246.791421    -0.000040  \n",
       "2017-08-10 04:00:00+00:00  245.027847    -0.014115  \n",
       "2017-08-11 04:00:00+00:00  244.222867     0.001477  "
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Configure a Monte Carlo simulation to forecast 10 years cumulative returns\n",
    "# The weights should be split 20% to AGG and 80% to SPY.\n",
    "# Run 500 samples.\n",
    "# YOUR CODE HERE\n",
    "mc_10_years = MCSimulation(\n",
    "    portfolio_data=prices_df,\n",
    "    num_trading_days=252*10,\n",
    "    weights=[0.20,0.80],\n",
    "    num_simulation=500\n",
    ")\n",
    "\n",
    "# Review the simulation input data\n",
    "# YOUR CODE HERE\n",
    "mc_10_years.portfolio_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 0.\n",
      "Running Monte Carlo simulation number 10.\n",
      "Running Monte Carlo simulation number 20.\n",
      "Running Monte Carlo simulation number 30.\n",
      "Running Monte Carlo simulation number 40.\n",
      "Running Monte Carlo simulation number 50.\n",
      "Running Monte Carlo simulation number 60.\n",
      "Running Monte Carlo simulation number 70.\n",
      "Running Monte Carlo simulation number 80.\n",
      "Running Monte Carlo simulation number 90.\n",
      "Running Monte Carlo simulation number 100.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 110.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 120.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 130.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 140.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 150.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 160.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 170.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 180.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 190.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 200.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 210.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 220.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 230.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 240.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 250.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 260.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 270.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 280.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 290.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 300.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 310.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 320.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 330.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 340.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 350.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 360.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 370.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 380.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 390.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 400.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 410.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 420.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 430.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 440.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 450.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 460.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 470.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 480.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Monte Carlo simulation number 490.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n",
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
      "  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>...</th>\n",
       "      <th>490</th>\n",
       "      <th>491</th>\n",
       "      <th>492</th>\n",
       "      <th>493</th>\n",
       "      <th>494</th>\n",
       "      <th>495</th>\n",
       "      <th>496</th>\n",
       "      <th>497</th>\n",
       "      <th>498</th>\n",
       "      <th>499</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2516</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2517</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2518</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2519</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2520</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2521 rows × 500 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      0    1    2    3    4    5    6    7    8    9    ...  490  491  492  \\\n",
       "0     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "1     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "2     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "3     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "4     1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "...   ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...  ...   \n",
       "2516  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "2517  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "2518  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "2519  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "2520  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  ...  1.0  1.0  1.0   \n",
       "\n",
       "      493  494  495  496  497  498  499  \n",
       "0     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "1     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "2     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "3     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "4     1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "...   ...  ...  ...  ...  ...  ...  ...  \n",
       "2516  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "2517  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "2518  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "2519  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "2520  1.0  1.0  1.0  1.0  1.0  1.0  1.0  \n",
       "\n",
       "[2521 rows x 500 columns]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the Monte Carlo simulation to forecast 10 years cumulative returns\n",
    "# YOUR CODE HERE\n",
    "mc_10_years.calc_cumulative_return()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'500 Simulations of Cumulative Portfolio Return Trajectories Over the Next 2520 Trading Days.'}>"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the 10-year Monte Carlo simulation by creating an\n",
    "# overlay line plot\n",
    "# YOUR CODE HERE\n",
    "mc_10_years_plot =  mc_10_years.plot_simulation()\n",
    "mc_10_years_plot\n",
    "\n",
    "# Output: C:\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:117: PerformanceWarning: DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
    "#  portfolio_cumulative_returns[n] = (1 + sim_df.fillna(0)).cumprod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Distribution of Final Cumuluative Returns Across All 500 Simulations'}, ylabel='Frequency'>"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the probability distribution of the 10-year Monte Carlo simulation \n",
    "# by plotting a histogram\n",
    "# YOUR CODE HERE\n",
    "mc_10_years.plot_distribution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\saint\\Documents\\Bootcamp\\Challenge #5\\financial-planner\\MCForecastTools.py:172: FutureWarning: The series.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  return metrics.append(ci_series)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "count           500.0\n",
       "mean              1.0\n",
       "std               0.0\n",
       "min               1.0\n",
       "25%               1.0\n",
       "50%               1.0\n",
       "75%               1.0\n",
       "max               1.0\n",
       "95% CI Lower      1.0\n",
       "95% CI Upper      1.0\n",
       "Name: 2520, dtype: float64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generate summary statistics from the 10-year Monte Carlo simulation results\n",
    "# Save the results as a variable\n",
    "# YOUR CODE HERE\n",
    "mc_10_years_summary = mc_10_years.summarize_cumulative_return()\n",
    "\n",
    "# Review the 10-year Monte Carlo summary statistics\n",
    "# YOUR CODE HERE\n",
    "display(mc_10_years_summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer the following questions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question: Using the current value of only the stock and bond portion of the member's portfolio and the summary statistics that you generated from the new Monte Carlo simulation, what are the lower and upper bounds for the expected value of the portfolio (with the new weights) with a 95% confidence interval?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63491.3\n"
     ]
    }
   ],
   "source": [
    "# Print the current balance of the stock and bond portion of the members portfolio\n",
    "# YOUR CODE HERE\n",
    "print(total_stocks_bonds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your initial investment has a 95% chance of being in the range between $63491.30 USD and $63491.30 USD in the next 10 years.\n"
     ]
    }
   ],
   "source": [
    "# Use the lower and upper `95%` confidence intervals to calculate the range of the possible outcomes for the current stock/bond portfolio\n",
    "ci_lower_ten_cumulative_return = mc_10_years_summary[8] * total_stocks_bonds\n",
    "ci_upper_ten_cumulative_return = mc_10_years_summary[9] * total_stocks_bonds\n",
    "\n",
    "# Print the result of your calculations\n",
    "# YOUR CODE HERE\n",
    "print(f\"Your initial investment has a 95% chance of being in the range between ${ci_lower_thirty_cumulative_return:.2f} USD and ${ci_upper_thirty_cumulative_return:.2f} USD in the next 10 years.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Question: Will weighting the portfolio more heavily to stocks allow the credit union members to retire after only 10 years?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "**Answer** No"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}