rw_lab_snippets_r.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "ir",
      "display_name": "R"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jlindsteadt/test/blob/master/rw_lab_snippets_r.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KEjfNpLI8wNd"
      },
      "source": [
        "## rw load rwrtool and other libraries\n",
        "\n",
        "- Add other required libraries to `libs_to_load`\n",
        "- For faster, loading, add their dependencies to `dependencies`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RMkP3zEUXN3f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "51c3d541-a716-4f59-9c11-e3779d04999c"
      },
      "source": [
        "# snippet: rw load rwrtools v0.4\n",
        "\n",
        "# lists of libraries: rwRtools dependencies (install but don't load) and libs_to_load (install and load)\n",
        "dependencies <- c(\n",
        "  \"pacman\", \"ttr\", \"googleauthr\", \"doparallel\", \"googlecloudstorager\", \n",
        "  \"iterators\", \"R.methodsS3\", \"openssl\", \"foreach\", \"xts\", \"R.oo\", \"feather\", \n",
        "  \"R.utils\"\n",
        ")\n",
        "libs_to_load <- c(\"tidyverse\", \"lubridate\", \"purrr\", \"stringr\", \"zoo\", \"glue\", \"here\")\n",
        "\n",
        "# comment out next two lines if not loading rsims\n",
        "rsims_dependencies <- c(\"stringr\", \"lubridate\", \"roll\", \"Rcpp\")\n",
        "dependencies <- c(dependencies, rsims_dependencies)\n",
        "\n",
        "# capitalisation of call to CRAN may not always match capitalisation of package name (eg library(doParallel) vs sudo apt install r-cran-doparallel).\n",
        "install_from_cran <- gsub(\"^(?!R\\\\.)([\\\\w]+)\", \"\\\\L\\\\1\", unique(c(libs_to_load, dependencies)), perl = TRUE)  # convert to lowercase all letters other than an \"R\" at the start followed by \".\"\n",
        "\n",
        "msg1 <- system2('sudo', args = c('apt-get', 'update'),\n",
        "  stdout = TRUE,\n",
        "  stderr = TRUE,\n",
        "  wait = TRUE\n",
        ")\n",
        "\n",
        "msg2 <- system2(\n",
        "  'sudo', \n",
        "  args = c('apt', 'install', sub('', 'r-cran-', install_from_cran, '-y --fix-missing')),\n",
        "  stdout = TRUE,\n",
        "  stderr = TRUE,\n",
        "  wait = TRUE\n",
        ")\n",
        "\n",
        "pacman::p_load(char = libs_to_load, install = FALSE)\n",
        "\n",
        "# install and load rwRtools from GH (sans dependencies)\n",
        "pacman::p_load_current_gh(\"RWLab/rwRtools\", dependencies = FALSE)\n",
        "\n",
        "# install and load rsims from GH (sans dependencies)\n",
        "pacman::p_load_current_gh(\"Robot-Wealth/rsims\", dependencies = FALSE)\n",
        "\n",
        "# output messages from install - optional, for debugging\n",
        "# msg\n",
        "\n",
        "# Set chart options\n",
        "options(repr.plot.width = 14, repr.plot.height=7)\n",
        "theme_set(theme_bw())\n",
        "theme_update(text = element_text(size = 20))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loading required package: pacman\n",
            "\n",
            "Warning message in library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE, :\n",
            "“there is no package called ‘pacman’”\n",
            "Installing package into ‘/usr/local/lib/R/site-library’\n",
            "(as ‘lib’ is unspecified)\n",
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "pillar       (1.5.0 -> 1.5.1 ) [CRAN]\n",
            "desc         (1.2.0 -> 1.3.0 ) [CRAN]\n",
            "iterators    (NA    -> 1.0.13) [CRAN]\n",
            "zoo          (NA    -> 1.8-9 ) [CRAN]\n",
            "R.methodsS3  (NA    -> 1.8.1 ) [CRAN]\n",
            "gargle       (NA    -> 1.0.0 ) [CRAN]\n",
            "waldo        (0.2.4 -> 0.2.5 ) [CRAN]\n",
            "foreach      (NA    -> 1.5.1 ) [CRAN]\n",
            "xts          (NA    -> 0.12.1) [CRAN]\n",
            "R.oo         (NA    -> 1.24.0) [CRAN]\n",
            "googleAuthR  (NA    -> 1.3.1 ) [CRAN]\n",
            "doParallel   (NA    -> 1.0.16) [CRAN]\n",
            "TTR          (NA    -> 0.24.2) [CRAN]\n",
            "dplyr        (1.0.4 -> 1.0.5 ) [CRAN]\n",
            "feather      (NA    -> 0.3.5 ) [CRAN]\n",
            "R.utils      (NA    -> 2.10.1) [CRAN]\n",
            "googleClo... (NA    -> 0.6.0 ) [CRAN]\n",
            "\u001b[32m✔\u001b[39m  \u001b[90mchecking for file ‘/tmp/RtmpfgVRiT/remotes3b3620b37c/RWLab-rwRtools-180a39c/DESCRIPTION’\u001b[39m\u001b[36m\u001b[39m\n",
            "\u001b[90m─\u001b[39m\u001b[90m  \u001b[39m\u001b[90mpreparing ‘rwRtools’:\u001b[39m\u001b[36m\u001b[39m\n",
            "\u001b[32m✔\u001b[39m  \u001b[90mchecking DESCRIPTION meta-information\u001b[39m\u001b[36m\u001b[39m\n",
            "\u001b[90m─\u001b[39m\u001b[90m  \u001b[39m\u001b[90mchecking for LF line-endings in source and make files and shell scripts\u001b[39m\u001b[36m\u001b[39m\n",
            "\u001b[90m─\u001b[39m\u001b[90m  \u001b[39m\u001b[90mchecking for empty or unneeded directories\u001b[39m\u001b[36m\u001b[39m\n",
            "\u001b[90m─\u001b[39m\u001b[90m  \u001b[39m\u001b[90mbuilding ‘rwRtools_0.0.0.9009.tar.gz’\u001b[39m\u001b[36m\u001b[39m\n",
            "   \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7GQeemWmrIV_"
      },
      "source": [
        "##rw data auth"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ks5n8ffFqg4a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "35f583aa-a7b1-4973-ce27-3cb467642eb8"
      },
      "source": [
        "# snippet: rw data auth v.0.1\n",
        "rwlab_data_auth()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "httpuv not installed, defaulting to out-of-band authentication\n",
            "\n",
            "Please point your browser to the following url: \n",
            "\n",
            "https://accounts.google.com/o/oauth2/auth?client_id=603366585132-0l5tra7gl2i20iftqangp7iskte4f3s0.apps.googleusercontent.com&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcloud-platform%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fuserinfo.email&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&response_type=code\n",
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Enter authorization code: 4/1AY0e-g6QMp-i_r9FStoe1yilhe1S8VSC_4X5Tg-C97tG3O9KTw9Nxghglzc\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "awXemKm0X1Pr"
      },
      "source": [
        "## rw ef quickstart"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yEDoGxVCX0Vs",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 419
        },
        "outputId": "6a77659f-3869-422a-8b83-aeab55e2657f"
      },
      "source": [
        "# snippet: rw ef quickstart v.0.1\n",
        "quicksetup(pod = \"EquityFactors\", path = \".\")\n",
        "prices %>% \n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Set default bucket name to 'equity_factors_research_pod'\n",
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Attempting download of  R1000_ohlc_1d.feather ...\n",
            "Transferring R1000_ohlc_1d.feather ... data is 690 Mb please be patient...\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "2021-03-10 02:18:32 -- Saved R1000_ohlc_1d.feather to ./R1000_ohlc_1d.feather (690 Mb)\n",
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "R1000_ohlc_1d.feather successfully transferred\n",
            "prices data object transferred and loaded as data.frame to Global Env\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  ticker date       open     high     low      close    unadjusted_close\n",
              "1 A      1999-11-19 27.39248 27.43152 25.39726 25.87450 40.7500         \n",
              "2 A      1999-11-22 26.35417 27.95354 25.55675 27.95354 43.6250         \n",
              "3 A      1999-11-23 27.11255 27.83188 25.67718 25.67718 40.2500         \n",
              "4 A      1999-11-24 25.59908 26.75453 25.51770 26.19469 41.0625         \n",
              "5 A      1999-11-26 26.07754 26.47461 25.99615 26.27608 41.1875         \n",
              "6 A      1999-11-29 26.15564 27.07350 25.87572 26.87497 42.1250         \n",
              "  volume   is_universe\n",
              "1 17624306 0          \n",
              "2  7609882 0          \n",
              "3  6913120 0          \n",
              "4  5603212 0          \n",
              "5  2000847 0          \n",
              "6  4714145 0          "
            ],
            "text/latex": "A tibble: 6 × 9\n\\begin{tabular}{lllllllll}\n ticker & date & open & high & low & close & unadjusted\\_close & volume & is\\_universe\\\\\n <chr> & <date> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl> & <dbl>\\\\\n\\hline\n\t A & 1999-11-19 & 27.39248 & 27.43152 & 25.39726 & 25.87450 & 40.7500 & 17624306 & 0\\\\\n\t A & 1999-11-22 & 26.35417 & 27.95354 & 25.55675 & 27.95354 & 43.6250 &  7609882 & 0\\\\\n\t A & 1999-11-23 & 27.11255 & 27.83188 & 25.67718 & 25.67718 & 40.2500 &  6913120 & 0\\\\\n\t A & 1999-11-24 & 25.59908 & 26.75453 & 25.51770 & 26.19469 & 41.0625 &  5603212 & 0\\\\\n\t A & 1999-11-26 & 26.07754 & 26.47461 & 25.99615 & 26.27608 & 41.1875 &  2000847 & 0\\\\\n\t A & 1999-11-29 & 26.15564 & 27.07350 & 25.87572 & 26.87497 & 42.1250 &  4714145 & 0\\\\\n\\end{tabular}\n",
            "text/markdown": "\nA tibble: 6 × 9\n\n| ticker &lt;chr&gt; | date &lt;date&gt; | open &lt;dbl&gt; | high &lt;dbl&gt; | low &lt;dbl&gt; | close &lt;dbl&gt; | unadjusted_close &lt;dbl&gt; | volume &lt;dbl&gt; | is_universe &lt;dbl&gt; |\n|---|---|---|---|---|---|---|---|---|\n| A | 1999-11-19 | 27.39248 | 27.43152 | 25.39726 | 25.87450 | 40.7500 | 17624306 | 0 |\n| A | 1999-11-22 | 26.35417 | 27.95354 | 25.55675 | 27.95354 | 43.6250 |  7609882 | 0 |\n| A | 1999-11-23 | 27.11255 | 27.83188 | 25.67718 | 25.67718 | 40.2500 |  6913120 | 0 |\n| A | 1999-11-24 | 25.59908 | 26.75453 | 25.51770 | 26.19469 | 41.0625 |  5603212 | 0 |\n| A | 1999-11-26 | 26.07754 | 26.47461 | 25.99615 | 26.27608 | 41.1875 |  2000847 | 0 |\n| A | 1999-11-29 | 26.15564 | 27.07350 | 25.87572 | 26.87497 | 42.1250 |  4714145 | 0 |\n\n",
            "text/html": [
              "<table class=\"dataframe\">\n",
              "<caption>A tibble: 6 × 9</caption>\n",
              "<thead>\n",
              "\t<tr><th scope=col>ticker</th><th scope=col>date</th><th scope=col>open</th><th scope=col>high</th><th scope=col>low</th><th scope=col>close</th><th scope=col>unadjusted_close</th><th scope=col>volume</th><th scope=col>is_universe</th></tr>\n",
              "\t<tr><th scope=col>&lt;chr&gt;</th><th scope=col>&lt;date&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th><th scope=col>&lt;dbl&gt;</th></tr>\n",
              "</thead>\n",
              "<tbody>\n",
              "\t<tr><td>A</td><td>1999-11-19</td><td>27.39248</td><td>27.43152</td><td>25.39726</td><td>25.87450</td><td>40.7500</td><td>17624306</td><td>0</td></tr>\n",
              "\t<tr><td>A</td><td>1999-11-22</td><td>26.35417</td><td>27.95354</td><td>25.55675</td><td>27.95354</td><td>43.6250</td><td> 7609882</td><td>0</td></tr>\n",
              "\t<tr><td>A</td><td>1999-11-23</td><td>27.11255</td><td>27.83188</td><td>25.67718</td><td>25.67718</td><td>40.2500</td><td> 6913120</td><td>0</td></tr>\n",
              "\t<tr><td>A</td><td>1999-11-24</td><td>25.59908</td><td>26.75453</td><td>25.51770</td><td>26.19469</td><td>41.0625</td><td> 5603212</td><td>0</td></tr>\n",
              "\t<tr><td>A</td><td>1999-11-26</td><td>26.07754</td><td>26.47461</td><td>25.99615</td><td>26.27608</td><td>41.1875</td><td> 2000847</td><td>0</td></tr>\n",
              "\t<tr><td>A</td><td>1999-11-29</td><td>26.15564</td><td>27.07350</td><td>25.87572</td><td>26.87497</td><td>42.1250</td><td> 4714145</td><td>0</td></tr>\n",
              "</tbody>\n",
              "</table>\n"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "za-e1RuL1LRl"
      },
      "source": [
        "## rw ef calc periodic returns\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KmnbgpXiqsw0"
      },
      "source": [
        "# snippet: rw ef calc periodic returns v.0.2\n",
        "# Calculate log and simple returns at the same periodicity as your data.\n",
        "# Assumes there are no gaps in your data\n",
        "returns <- prices %>%\n",
        "  group_by(ticker) %>%\n",
        "  arrange(date) %>%\n",
        "  mutate(log_return = log(close / lag(close, n = 1))) %>%\n",
        "  mutate(simple_return = close / lag(close, n = 1) - 1) %>%\n",
        "  na.omit() "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qoa1tPbqcJiw"
      },
      "source": [
        "##rw ef plot return histogram"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4bQF_JLt7kog"
      },
      "source": [
        "# snippet: rw ef plot return histogram v.0.1\n",
        "returns %>%\n",
        "  filter(is_universe == 1) %>%\n",
        "  ggplot(aes(x = log_return)) +\n",
        "    geom_histogram(position = 'identity', bins = 100) +\n",
        "    ggtitle('Distribution of Log Returns') "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YZSeCTue_6vQ"
      },
      "source": [
        "##rw ef align feature target"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "evyvmYX81nio"
      },
      "source": [
        "# snippet: rw ef align feature target v.0.1\n",
        "# Create feature data frame of date, ticker, feature\n",
        "# Date is the day of the feature measurement\n",
        "# The feature cannot be calculated using data that was unavailable on this date\n",
        "# The example calculates simple 252 day momentum as the feature\n",
        "feature <- prices %>%\n",
        "  group_by(ticker) %>%\n",
        "  arrange(date) %>%\n",
        "  mutate(feature = close / lag(close, n = 252) - 1) %>%\n",
        "  na.omit() %>%\n",
        "  select(ticker, date, feature)\n",
        "\n",
        "# Create target date frame of date, ticker, target\n",
        "# Target should align with the relevant date of the feature\n",
        "# If it's a return calculation the date should be the start of the forward return period  \n",
        "# The example calculates log returns 20 days ahead of the factor measurement\n",
        "target <- prices %>%\n",
        "  group_by(ticker) %>%\n",
        "  arrange(date) %>%\n",
        "  mutate(target = log(lead(close, n = 20) / close)) %>%\n",
        "  na.omit() %>%\n",
        "  select(ticker, date, close, volume, is_universe, target)\n",
        "\n",
        "# Align feature and target in a single data frame\n",
        "pacman::p_load('lubridate') # Useful for pulling the year out of the date easily\n",
        "feature_target <- feature %>%\n",
        "  inner_join(target, by = c('date','ticker')) %>%\n",
        "  mutate(\n",
        "    year = year(date),\n",
        "    feature = lag(feature, n=1) # don't lag if you want to assume you can trade on the close of the day of factor\n",
        "  ) %>%\n",
        "  na.omit() %>%\n",
        "  # Filter stocks that were not in the index, or were not trading\n",
        "  filter(\n",
        "    is_universe == 1,\n",
        "    volume > 0,\n",
        "    close > 5\n",
        "  )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WPcgvR8k5LM8"
      },
      "source": [
        "## rw ef plot feature target universe size"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IgnLrUIW5f7k"
      },
      "source": [
        "# snippet: rw ef plot feature target universe size v.0.2\n",
        "feature_target %>% \n",
        "  group_by(date) %>%\n",
        "  summarise(universe_count = n()) %>%\n",
        "  ggplot(aes(x = date, y = universe_count)) + \n",
        "    geom_line() +\n",
        "    ggtitle('Stocks in universe each day')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5aafv3uC5uSo"
      },
      "source": [
        "## rw ef plot feature target scatter"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A3JPSHpv5y0r"
      },
      "source": [
        "# snippet: rw ef plot feature target scatter v.0.2\n",
        " feature_target %>%\n",
        "  filter(year %in% c(YEARS)) %>%\n",
        "    ggplot(aes(x = feature, y = target)) +\n",
        "      geom_point() +\n",
        "      geom_smooth(method=lm) +\n",
        "      ggtitle('Raw (unscaled) target vs feature')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zczZi9Bu6Gfx"
      },
      "source": [
        "## rw ef calc feature buckets"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SHbEgDH66Sge"
      },
      "source": [
        "# snippet: rw ef calc feature buckets v.0.2\n",
        "# This example sorts the feature into 10 buckets (deciles)\n",
        "feature_target %>%\n",
        "  group_by(date) %>%\n",
        "  mutate(decile = ntile(feature, n = 10)) %>%\n",
        "  mutate(bucket = factor(decile)) # Bucket is a factor - which is useful for plotting"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z-foelOM6mO9"
      },
      "source": [
        "## rw ef plot feature bucket histogram"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xCa1PsfBP1rd"
      },
      "source": [
        "# snippet: rw ef plot feature bucket histogram v.0.2\n",
        "feature_target %>% \n",
        "  ggplot(aes(x = feature, fill = bucket)) +\n",
        "    geom_histogram(position = 'identity', bins = 100) # +xlim(c(MIN, MAX))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BpklmFaL66oY"
      },
      "source": [
        "## rw ef plot mean target by feature bucket"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xhL0GTktOkC-"
      },
      "source": [
        "# snippet: rw ef plot mean target by feature bucket v.0.2\n",
        "feature_target %>% \n",
        "  group_by(bucket) %>%\n",
        "  summarise(mean_target = mean(target)) %>%\n",
        "  ggplot(aes(x = bucket, y = mean_target)) +\n",
        "    geom_bar(stat = 'identity') +\n",
        "    ggtitle('Mean Returns vs Feature Bucket')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8EPoKCYe7wC4"
      },
      "source": [
        "## rw ef plot boxplot by feature bucket"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4xeFNNOg72G3"
      },
      "source": [
        "# snippet: rw ef plot boxplot by feature bucket v.0.2\n",
        "feature_target %>%\n",
        "  group_by(bucket) %>%\n",
        "  ggplot(aes(x = bucket, y = target)) +\n",
        "    geom_boxplot() +\n",
        "    ggtitle('Return distribution by Decile')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SvoDwGxk8NDj"
      },
      "source": [
        "## rw ef plot mean target by feature bucket by year"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Twc_tEqS8Tah"
      },
      "source": [
        "# snippet: rw ef plot mean target by feature bucket by year v.0.2\n",
        "feature_target %>% \n",
        "  group_by(bucket, year) %>%\n",
        "    summarise(mean_target = mean(target)) %>% \n",
        "    ggplot(aes(x = bucket, y = mean_target)) +\n",
        "      geom_bar(stat = 'identity') +\n",
        "      facet_wrap(~year)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s2lugCsQ8bFJ"
      },
      "source": [
        "## rw ef demean by date"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kuJKVIJ08j97"
      },
      "source": [
        "# snippet: rw ef demean by date v.0.2\n",
        "feature_target %>%\n",
        "  group_by(date) %>%\n",
        "  mutate(demeaned_target = target - mean(target))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4yjG8INH9FnX"
      },
      "source": [
        "## rw ef plot top minus bottom by year"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PWKbiRVb9E_s"
      },
      "source": [
        "# snippet: rw ef plot top minus bottom by year\n",
        "top_decile <- feature_target %>%\n",
        "  filter(decile == 10) %>%\n",
        "  group_by(year) %>%\n",
        "  summarise(top_returns = mean(target)) \n",
        "\n",
        "bottom_decile <- feature_target %>%\n",
        "  filter(decile == 1) %>%\n",
        "  group_by(year) %>%\n",
        "  summarise(bottom_returns = mean(target)) \n",
        "\n",
        "top_decile %>%\n",
        "  inner_join(bottom_decile, by = 'year') %>%\n",
        "  mutate(top_minus_bottom = top_returns - bottom_returns) %>%\n",
        "  mutate(annualised_returns = top_minus_bottom * 252) %>% # Assumes you have daily data\n",
        "  ggplot(aes(x=year, y = annualised_returns)) +\n",
        "    geom_line() +\n",
        "    ggtitle('Top Minus Bottom Annualised Returns')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nJKXbKFgTUQE"
      },
      "source": [
        "## rw fx list available Zorro Assets Lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o5TRM6ZKTOct"
      },
      "source": [
        "# snippet: output available Zorro Assets Lists v0.1\n",
        "assets_lists_summary <- googleCloudStorageR::gcs_list_objects(\n",
        "  bucket = \"fx_research_pod\",\n",
        "  detail = \"summary\",\n",
        "  prefix = \"feather/Zorro-Assets-Lists/\"\n",
        ") %>% \n",
        "  mutate(name = gsub(\".csv\", \"\", gsub(\"feather/Zorro-Assets-Lists/\", \"\", name))) %>% \n",
        "  filter(name != \"\")\n",
        "\n",
        "list_names <- assets_lists_summary %>%\n",
        "  select(name) %>%\n",
        "  pull()\n",
        "\n",
        "list_names"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bwVLNGn8JOwu"
      },
      "source": [
        "## rw fx get zorro assets list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I7YZFuowJEsZ"
      },
      "source": [
        "# snippet: load Zorro Assets List v0.1\n",
        "list_name <- \"AssetsDWX-FX-USD\"   # change as necessary\n",
        "assets_list <- rwRtools::fx_get_asset_list(list_name, force_update = TRUE)\n",
        "assets_list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6xs8Tz-nLHWi"
      },
      "source": [
        "## rw fx load daily prices "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MBLTXL1m0TSl"
      },
      "source": [
        "# snippet: load daily price data v0.1\n",
        "# tickers <- assets_list$Name[1:7]\n",
        "daily_df <- rwRtools::fx_get_daily_OHLC(tickers, force_update = TRUE)\n",
        "daily_df %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jwNjeKYV0VUu"
      },
      "source": [
        "## rw fx load hourly prices"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UOoWiOme0Vi1"
      },
      "source": [
        "# snippet: load hourly price data v0.1\n",
        "# tickers <- assets_list$Name[1:3]\n",
        "hourly_df <- rwRtools::fx_get_hourly_OHLC(tickers, force_update = TRUE)\n",
        "hourly_df %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "84AKCej90Vru"
      },
      "source": [
        "## rw fx convert prices to common quote currency"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fAGXKVwk1DDL"
      },
      "source": [
        "# snippet: convert price data to common quote currency v0.1\n",
        "prices_conv_df <- rwRtools::fx_convert_common_quote_currency(prices_df, quote_currency = \"USD\")\n",
        "prices_conv_df %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uMQaCZM610xB"
      },
      "source": [
        "## rw fx get policy rates"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZfG4qZ9b11IH"
      },
      "source": [
        "# snippet: get historical central bank policy rates v0.1\n",
        "currencies <- c(\"AUD\", \"NZD\", \"GBP\", \"USD\", \"EUR\")\n",
        "rates <- rwRtools::fx_get_policy_rates(currencies, force_update = TRUE)\n",
        "rates %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "swQtsF8h11Z9"
      },
      "source": [
        "## rw fx total return index"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S1BpwztP2bPE"
      },
      "source": [
        "# snippet: create historical total return indexes v0.1\n",
        "total_return_index <- rwRtools::fx_total_return_index(daily_df, rates)\n",
        "total_return_index %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vGEIhJGqttij"
      },
      "source": [
        "## rw fx plot returns decomposed into spot and interest"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LfFuB8UXtt1w"
      },
      "source": [
        "# snippet: plot returns decomposed into spot and interest v0.1\n",
        "# prices_df has columns Ticker, Date, Spot_Return_Index, Interest_Return_Index, Total_Return_Index\n",
        "\n",
        "prices_df %>%\n",
        "  select(Ticker, Date, Spot_Return_Index, Interest_Return_Index, Total_Return_Index) %>%\n",
        "  pivot_longer(cols = c('Spot_Return_Index', 'Interest_Return_Index', 'Total_Return_Index'), names_to = 'type', values_to = 'value') %>%\n",
        "  ggplot(aes(x = Date, y = value, colour = type)) +\n",
        "    geom_line() +\n",
        "    facet_wrap(~Ticker) +\n",
        "    theme_bw()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CitDEsKmXG7r"
      },
      "source": [
        "## rw fx long data frame of converted pairs in local currencies"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rPRs1fsEXGwj"
      },
      "source": [
        "# snippet: create long data.frame with prices in common quote currencies v0.1\n",
        "converted_df <- map(\n",
        "  c(\"USD\", \"EUR\", \"JPY\"), \n",
        "  ~fx_convert_common_quote_currency(prices_df, .)\n",
        ") %>% \n",
        "  bind_rows()\n",
        "\n",
        "converted_df %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kns5g7TgXdA9"
      },
      "source": [
        "## rw fx make data for intraday seasonality"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gUwyk9ONXGkW"
      },
      "source": [
        "# snippet: convert prices df to returns df with seasonality information relevant to a local timezone v0.1\n",
        "# designed for use in researching fx intraday seasonality in local business hours\n",
        "make_seasonal_data <- function(prices_df, local_ccy = \"USD\", years = 2009:2020) {\n",
        "  timezone_map <- c(\"USD\" = \"America/New_York\", \"EUR\" = \"Europe/Berlin\", \"JPY\" = \"Japan\")\n",
        "\n",
        "  if(is.na(timezone_map[local_ccy])) {\n",
        "    stop(\"local_ccy should be USD, EUR, or JPY\")\n",
        "  }\n",
        "  \n",
        "  timezone <- timezone_map[local_ccy]\n",
        "\n",
        "  prices_df %>%\n",
        "    filter(str_detect(Ticker, glue::glue(\"[A-Z]{{3}}{local_ccy}\"))) %>%\n",
        "    # convert timezone from UTC before getting seaonality information\n",
        "    mutate(Datetime = lubridate::with_tz(Datetime, tz = timezone)) %>%\n",
        "    # calculate returns and seasonality information\n",
        "    group_by(Ticker) %>% \n",
        "    arrange(Datetime) %>%\n",
        "    mutate(\n",
        "      returns = Close / dplyr::lag(Close) - 1,\n",
        "      hour = lubridate::hour(Datetime),\n",
        "      year = lubridate::year(Datetime),\n",
        "      month = lubridate::month(Datetime),\n",
        "      day = lubridate::day(Datetime)\n",
        "    ) %>%\n",
        "    filter(year %in% years) %>%\n",
        "    select(Ticker, Datetime, year, month, day, hour, returns) %>%\n",
        "    na.omit() %>%\n",
        "    mutate(returns_detrended = returns - mean(returns, na.rm = TRUE)) %>% \n",
        "    group_by(Ticker, hour) %>%\n",
        "      summarise(\n",
        "        meanreturns = mean(returns * 100),\n",
        "        meanreturns_detrended = mean(returns_detrended * 100),\n",
        "        # remove Ticker, hour grouping\n",
        "        .groups = \"drop\"\n",
        "      ) %>%\n",
        "      # group by Ticker for cum returns calculations\n",
        "      group_by(Ticker) %>%\n",
        "      mutate(\n",
        "        cumreturns = cumsum(meanreturns),\n",
        "        cumreturns_detrended = cumsum(meanreturns_detrended)\n",
        "      ) %>% \n",
        "      pivot_longer(\n",
        "        cols = c(meanreturns, cumreturns, meanreturns_detrended, cumreturns_detrended), \n",
        "        names_to = \"return_type\", \n",
        "        values_to = \"return\"\n",
        "      )\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FxGe33FEXiXO"
      },
      "source": [
        "## rw fx plots for intraday seasonality "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0YGmm3CmXGVq"
      },
      "source": [
        "# snippet: intraday seasonality plot of hourly returns (bars) and cumulative hourly returns (lines) v0.1\n",
        "# designed for use in researching fx intraday seasonality in local business hours\n",
        "seasonality_barlineplot <- function(prices_df, local_ccy = \"USD\", years = 2009:2020, detrend = TRUE) {\n",
        "  timezone_map <- c(\"USD\" = \"America/New_York\", \"EUR\" = \"Europe/Berlin\", \"JPY\" = \"Japan\")\n",
        "  \n",
        "  if(is.na(timezone_map[local_ccy])) {\n",
        "    stop(\"local_ccy should be USD, EUR, or JPY\")\n",
        "  }\n",
        "\n",
        "  timezone <- timezone_map[local_ccy]\n",
        "  \n",
        "  seasonal_df <- prices_df %>%\n",
        "    make_seasonal_data(local_ccy, years) \n",
        "  \n",
        "  if(detrend) \n",
        "  {\n",
        "    r_type = \"meanreturns_detrended\"\n",
        "    cumr_type = \"cumreturns_detrended\"\n",
        "    title = glue::glue('Detrended Mean and Cumulative Returns by Hour ({timezone}) {years[1]} - {years[length(years)]}')\n",
        "    y_label = \"Detrended Returns %\"\n",
        "  } else {\n",
        "    r_type = \"meanreturns\"\n",
        "    cumr_type = \"cumreturns\"\n",
        "    title = glue::glue('Mean and Cumulative Returns by Hour ({timezone}) {years[1]} - {years[length(years)]}')\n",
        "    y_label = \"Returns %\"\n",
        "  }\n",
        "  \n",
        "    ggplot() +\n",
        "      geom_bar(\n",
        "        data = seasonal_df %>% filter(return_type == r_type),\n",
        "        aes(x = as.factor(hour), y = return, fill = Ticker),\n",
        "        stat='identity', \n",
        "        position = position_dodge()\n",
        "      ) +\n",
        "      geom_line(\n",
        "        data = seasonal_df %>% filter(return_type == cumr_type),\n",
        "        aes(x = as.factor(hour), y = return, colour = Ticker, group = Ticker),\n",
        "        size = 1.\n",
        "      ) +\n",
        "      geom_vline(xintercept = \"9\", colour = \"blue\", size = 1., linetype = 2) +\n",
        "      geom_vline(xintercept = \"16\", colour = \"blue\", size = 1., linetype = 2) +\n",
        "      labs(\n",
        "        title = title,\n",
        "        x = glue::glue(\"Hour ({timezone})\"),\n",
        "        y = y_label\n",
        "      ) +\n",
        "      coord_cartesian(ylim = c(-0.06, 0.06)) +\n",
        "      facet_wrap(~Ticker) +\n",
        "      theme_bw() +\n",
        "      theme(legend.position = 'none')\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FCTq4uKK77-j"
      },
      "source": [
        "## rw fx calculate factor quantiles"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gW8ruJ5N78Cq"
      },
      "source": [
        "# snippet: calculate factor quantiles by ranking tickers by factor values each period v0.1a\n",
        "num_qtiles <- 4\n",
        "\n",
        "quantile_df <- factor_df %>%\n",
        "  group_by(Date) %>%\n",
        "  mutate(quantile = factor(ntile(factor, num_qtiles)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PoeIvGAr78GC"
      },
      "source": [
        "## rw fx append forward returns"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sdWdxekq78Ik"
      },
      "source": [
        "# snippet: append forward returns v0.1\n",
        "# quantile_df has columns Ticker, Total_Return_Index\n",
        "# note creates forward_return_prd_names vector for later creating an ordered factor from forward return periods\n",
        "pacman::p_load(glue)\n",
        "\n",
        "forward_return_periods <- c(1, 5, 10, 20, 30, 60)\n",
        "forward_return_prd_names <- c()\n",
        "\n",
        "for(prd in forward_return_periods) {\n",
        "  prd <- enquo(prd)\n",
        "  quantile_df <- quantile_df %>%\n",
        "    group_by(Ticker) %>%\n",
        "    mutate(\n",
        "      !!glue(\"return_{quo_name(prd)}\") := lead(Total_Return_Index / lag(Total_Return_Index, !!prd) - 1, !!prd)\n",
        "    )\n",
        "\n",
        "    forward_return_prd_names <- c(forward_return_prd_names, glue(\"return_{quo_name(prd)}\"))\n",
        "}\n",
        "\n",
        "quantile_df <- quantile_df %>%\n",
        "  ungroup()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yp_0vj0cvuzK"
      },
      "source": [
        "## rw fx take factor, quantile and forward returns columns, and pivot longer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "icqwuWo7vu7L"
      },
      "source": [
        "# snippet: fx take factor, quantile and forward returns columns, and pivot longer v0.1\n",
        "analysis_df <- quantile_df %>%\n",
        "  select(Date, Ticker, factor, quantile, starts_with(\"return\")) %>%\n",
        "  pivot_longer(starts_with(\"return\"), names_to = \"fwd_return_prd\", values_to = \"fwd_return\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZEdAlmwqvvBr"
      },
      "source": [
        "## rw fx calculate mean forward returns to quantiles"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fu4ClFDJvvGc"
      },
      "source": [
        "# snippet: calculate mean forward returns to quantiles v0.1\n",
        "# note uses vector forward_return_prd_names to create an ordered factor from fwd_return_prd\n",
        "summary_df <- analysis_df %>%\n",
        "  group_by(quantile, fwd_return_prd) %>%\n",
        "  summarise(return = mean(fwd_return, na.rm = TRUE), .groups = \"drop\") %>%\n",
        "  mutate(fwd_return_prd = factor(fwd_return_prd, levels = forward_return_prd_names, ordered = TRUE))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n1gPiguxwd6Q"
      },
      "source": [
        "## rw fx factor plot of mean forward returns by quantile"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4v3tmeQ4vvL0"
      },
      "source": [
        "# snippet: factor plot of mean forward returns by quantile v0.1\n",
        "summary_df %>%\n",
        "  ggplot(aes(x = quantile, y = return, fill = fwd_return_prd)) + \n",
        "    geom_bar(stat = 'identity', position = position_dodge()) +\n",
        "    theme_bw()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i8Agv0hX5KL5"
      },
      "source": [
        "## rw fx calculate mean returns by quantile and year\n",
        "\n",
        "Useful for looking at the stability of a factor's predicitve power over time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fZznCJQFw5RT"
      },
      "source": [
        "# snippet: calculate mean returns by quantile by year v0.1\n",
        "annual_summary_df <- analysis_df %>%\n",
        "  mutate(Year = year(Date)) %>%\n",
        "  group_by(Year, fwd_return_prd, quantile) %>%\n",
        "  summarise(Mean = mean(fwd_return, na.rm = TRUE), .groups = \"drop\") %>%\n",
        "  na.omit()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xwrf8xl85U_Y"
      },
      "source": [
        "## rw fx plot mean returns by quantile and year\n",
        "\n",
        "Useful for looking at the stability of a factor's predictive power over time"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8z4QByRp5VIZ"
      },
      "source": [
        "# snippet: plot mean returns by quantile by year v0.1\n",
        "annual_summary_df %>%\n",
        "  ggplot(aes(x = Year, y = Mean, colour = quantile)) +\n",
        "    geom_line() +\n",
        "    geom_point() +\n",
        "    facet_wrap(~fwd_return_prd, scales = \"free_y\") +\n",
        "    labs(\n",
        "      title = glue(\"{f}-day price momentum mean quantile returns by year\")\n",
        "    ) +\n",
        "    theme_bw()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "er6Ygc3J77wL"
      },
      "source": [
        "## rw fx calculate various momentum factors\n",
        "\n",
        "Several functions for estimating momentum in various ways"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J4vg_cCN774q"
      },
      "source": [
        "# snippet: function for calculating a momentum factor v0.1\n",
        "\n",
        "#' Calculate price momentum over some lookback\n",
        "#'\n",
        "#' @param prices_df dataframe of prices\n",
        "#' @param formation_period period over which to calculate momentum\n",
        "#' @param factor_col the column of prices_df over which to calculate momentum factor\n",
        "#' @param ticker_col the column of prices_df containing the ticker names\n",
        "#'\n",
        "#' @return prices_df grouped by ticker with momentum factor column\n",
        "#' @export\n",
        "#'\n",
        "#' @examples\n",
        "#' prices <- data.frame(\n",
        "#'   Ticker = rep(\"EURUSD\", 6),\n",
        "#'   Close = c(1.11567, 1.11609, 1.11823, 1.11990, 1.12056, 1.12161)\n",
        "#'   )\n",
        "#' momo_factor(prices, 3)\n",
        "momo_factor <- function(prices_df, formation_period = 60, factor_col = Close, ticker_col = Ticker) {\n",
        "\n",
        "  factor_col <- dplyr::enquo(factor_col)\n",
        "  ticker_col <- dplyr::enquo(ticker_col)\n",
        "\n",
        "  # Calculate factor\n",
        "  prices_df %>%\n",
        "    dplyr::group_by(!!ticker_col) %>%\n",
        "    dplyr::mutate(\n",
        "      factor = TTR::ROC(!!factor_col, n = formation_period, type = 'discrete', na.pad = TRUE)\n",
        "    )\n",
        "}\n",
        "\n",
        "# snippet: function for calculating a momentum factor based on the ratio of two SMAs v0.1\n",
        "#' SMA Ratio Factor\n",
        "#'\n",
        "#' Calculate ratio between shorter term and longer term moving average as  a momentum measure.\n",
        "#  A typical setting might be to set the short SMA to 1/10th the length of the longer SMA.\n",
        "#'\n",
        "#' @param prices_df dataframe of prices\n",
        "#' @param formation_period period over which to calculate long SMA\n",
        "#' @param short_period period over which to calculate short SMA\n",
        "#' @param factor_col the column of prices_df over which to calculate momentum factor\n",
        "#' @param ticker_col the column of prices_df containing the ticker names\n",
        "#'\n",
        "#' @return prices_df grouped by ticker with long SMA, short SMA, and factor columns\n",
        "#' @export\n",
        "#'\n",
        "#' @examples\n",
        "#' prices <- data.frame(\n",
        "#'   Ticker = rep(\"EURUSD\", 6),\n",
        "#'   Close = c(1.11567, 1.11609, 1.11823, 1.11990, 1.12056, 1.12161)\n",
        "#'   )\n",
        "#' sma_ratio_factor(prices, 3, 2)\n",
        "sma_ratio_factor <- function(prices_df, formation_period = 60, short_period = 6, factor_col = Close, ticker_col = Ticker) {\n",
        "  factor_col <- dplyr::enquo(factor_col)\n",
        "  ticker_col <- dplyr::enquo(ticker_col)\n",
        "\n",
        "  # calculate factor\n",
        "  prices_df %>%\n",
        "    dplyr::group_by(!!ticker_col) %>%\n",
        "    dplyr::mutate(\n",
        "      long_sma = TTR::SMA(!!factor_col, n = formation_period, na.pad = TRUE),\n",
        "      short_sma = TTR::SMA(!!factor_col, n = short_period, na.pad = TRUE),\n",
        "      factor = (short_sma / long_sma) - 1\n",
        "    )\n",
        "}\n",
        "\n",
        "# snippet: function for calculating a momentum factor based on the ratio of price to a SMA v0.1\n",
        "#' Price to SMA factor\n",
        "#'\n",
        "#' Ratio of current price and SMA\n",
        "#'\n",
        "#' @param prices_df dataframe of prices\n",
        "#' @param formation_period period over which to calculate SMA\n",
        "#' @param factor_col the column of prices_df over which to calculate factor\n",
        "#' @param ticker_col the column of prices_df containing the ticker names\n",
        "#'\n",
        "#' @return prices_df grouped by ticker with SMA and factor columns\n",
        "#' @export\n",
        "#'\n",
        "#' @examples\n",
        "#' prices <- data.frame(\n",
        "#'   Ticker = rep(\"EURUSD\", 6),\n",
        "#'   Close = c(1.11567, 1.11609, 1.11823, 1.11990, 1.12056, 1.12161)\n",
        "#'   )\n",
        "#' price_to_sma_factor(prices, 3)\n",
        "price_to_sma_factor <- function(prices_df, formation_period = 60, factor_col = Close, ticker_col = Ticker) {\n",
        "  factor_col <- dplyr::enquo(factor_col)\n",
        "  ticker_col <- dplyr::enquo(ticker_col)\n",
        "\n",
        "  # calculate factor\n",
        "  prices_df %>%\n",
        "    dplyr::group_by(!!ticker_col) %>%\n",
        "    dplyr::mutate(\n",
        "      sma = TTR::SMA(!!factor_col, n = formation_period, na.pad = TRUE),\n",
        "      factor = (!!factor_col / sma) - 1)\n",
        "}\n",
        "\n",
        "# snippet: function for calculating a momentum factor based on the slope of a SMA v0.1\n",
        "#' SMA slope factor\n",
        "#'\n",
        "#' 1-period slope of a simple moving average as momentum factor.\n",
        "#'\n",
        "#' @param prices_df dataframe of prices\n",
        "#' @param formation_period period over which to calculate SMA\n",
        "#' @param factor_col the column of prices_df over which to calculate factor\n",
        "#' @param ticker_col the column of prices_df containing the ticker names\n",
        "#'\n",
        "#' @return prices_df grouped by ticker with SMA, lagged SMA, and factor columns\n",
        "#' @export\n",
        "#'\n",
        "#' @examples\n",
        "#' prices <- data.frame(\n",
        "#'   Ticker = rep(\"EURUSD\", 6),\n",
        "#'   Close = c(1.11567, 1.11609, 1.11823, 1.11990, 1.12056, 1.12161)\n",
        "#'   )\n",
        "#' sma_slope_factor(prices, 3)\n",
        "sma_slope_factor <- function(prices_df, formation_period = 60, factor_col = Close, ticker_col = Ticker) {\n",
        "  factor_col <- dplyr::enquo(factor_col)\n",
        "  ticker_col <- dplyr::enquo(ticker_col)\n",
        "\n",
        "  # calculate factor\n",
        "  prices_df %>%\n",
        "    dplyr::group_by(!!ticker_col) %>%\n",
        "    dplyr::mutate(\n",
        "      sma = TTR::SMA(!!factor_col, n = formation_period, na.pad = TRUE),\n",
        "      lag_sma = dplyr::lag(sma, n = 1),\n",
        "      factor = (sma / lag_sma) - 1\n",
        "    )\n",
        "}\n",
        "\n",
        "# snippet: function for calculating a momentum factor based on the current value's percentile over some lookback v0.1\n",
        "#' Percentile factor\n",
        "#'\n",
        "#' Current value's percentile over a rolling lookback period.\n",
        "#'\n",
        "#' @param prices_df dataframe of prices\n",
        "#' @param formation_period period over which to calculate percentile rank\n",
        "#' @param factor_col the column of prices_df over which to calculate factor\n",
        "#' @param ticker_col the column of prices_df containing the ticker names\n",
        "#'\n",
        "#' @return prices_df grouped by ticker with factor column\n",
        "#' @export\n",
        "#'\n",
        "#' @examples\n",
        "#' prices <- data.frame(\n",
        "#'   Ticker = rep(\"EURUSD\", 6),\n",
        "#'   Close = c(1.11567, 1.11609, 1.11823, 1.11990, 1.12056, 1.12161)\n",
        "#'   )\n",
        "#' percentile_factor(prices, 3)\n",
        "percentile_factor <- function(prices_df, formation_period = 60, factor_col = Close, ticker_col = Ticker) {\n",
        "  factor_col <- dplyr::enquo(factor_col)\n",
        "  ticker_col <- dplyr::enquo(ticker_col)\n",
        "\n",
        "  # calculate factor\n",
        "  prices_df %>%\n",
        "    group_by(!!ticker_col) %>%\n",
        "    mutate(factor = TTR::runPercentRank(!!factor_col, n = formation_period))\n",
        "}\n",
        "\n",
        "# snippet: function for calculating a momentum factor based on the zscore v0.1\n",
        "#' Z-score factor\n",
        "#'\n",
        "#' Z-score of current factor value over rolling lookback period\n",
        "#'\n",
        "#' @param prices_df dataframe of prices\n",
        "#' @param formation_period period over which to calculate z-score\n",
        "#' @param factor_col the column of prices_df over which to calculate factor\n",
        "#' @param ticker_col the column of prices_df containing the ticker names\n",
        "#'\n",
        "#' @return prices_df grouped by ticker with running mean, running sd, and factor columns\n",
        "#' @export\n",
        "#'\n",
        "#' @examples\n",
        "#' prices <- data.frame(\n",
        "#'   Ticker = rep(\"EURUSD\", 6),\n",
        "#'   Close = c(1.11567, 1.11609, 1.11823, 1.11990, 1.12056, 1.12161)\n",
        "#'   )\n",
        "#' zscore_factor(prices, 3)\n",
        "zscore_factor <- function(prices_df, formation_period = 60, factor_col = Close, ticker_col = Ticker) {\n",
        "  factor_col <- dplyr::enquo(factor_col)\n",
        "  ticker_col <- dplyr::enquo(ticker_col)\n",
        "\n",
        "  # calculate factor\n",
        "  prices_df %>%\n",
        "    group_by(!!ticker_col) %>%\n",
        "    mutate(\n",
        "      running_mean = TTR::runMean(!!factor_col, n = formation_period),\n",
        "      running_sd = TTR::runSD(!!factor_col, n = formation_period),\n",
        "      factor = (!!factor_col - running_mean) / running_sd\n",
        "    )\n",
        "}\n",
        "\n",
        "# snippet: function for calculating a momentum factor based on the ratio of sum of positive returns to sum of negative returns v0.1\n",
        "#' Sign ratio factor\n",
        "#'\n",
        "#' The ratio of the sum of positive returns to the sum of negative returns\n",
        "#' over the `formation_period`, for `num_formation_periods`.\n",
        "#'\n",
        "#' @param prices_df dataframe of prices\n",
        "#' @param formation_period period over which to calculate the factor\n",
        "#' @param num_formation_periods the number of formation periods to use in the calcuation of sign ratio\n",
        "#' @param factor_col the column of prices_df over which to calculate factor\n",
        "#' @param ticker_col the column of prices_df containing the ticker names\n",
        "#'\n",
        "#' @return prices_df grouped by ticker with factor column\n",
        "#'\n",
        "#' @details Say `formation_period = 3` and `num_formation_periods = 4`. This will calculate the sign ratio over 4 windows of 3 periods each. Say those four three-period returns are 1%, -3%, 2% and -2,5%, the sign ratio would be \\eqn{\\frac{0.01 + 0.02}{0.03 + 0.025} = 0.545}\n",
        "#'\n",
        "#' The number of leading NAs in the factor vector will equal `formation_period * num_formation_periods`\n",
        "#'\n",
        "#' @export\n",
        "#' @examples\n",
        "#' prices <- data.frame(\n",
        "#'   Ticker = rep(\"EURUSD\", 6),\n",
        "#'   Close = c(1.11567, 1.11609, 1.11823, 1.11990, 1.12056, 1.12161)\n",
        "#'   )\n",
        "#' sign_ratio_factor(prices, 3, 10)\n",
        "sign_ratio_factor <- function(prices_df, formation_period = 22, num_formation_periods = 12, factor_col = Close, ticker_col = Ticker) {\n",
        "  factor_col <- dplyr::enquo(factor_col)\n",
        "  ticker_col <- dplyr::enquo(ticker_col)\n",
        "\n",
        "  # Calculate return sign ratio factor\n",
        "  prices_df %>%\n",
        "    group_by(!!ticker_col) %>%\n",
        "    mutate(\n",
        "      factor = zoo::rollapplyr(\n",
        "        !!factor_col,\n",
        "        width = formation_period*num_formation_periods,\n",
        "        fill = NA,\n",
        "        FUN = function(x){\n",
        "          last_idx <- dplyr::last(zoo::index(x))\n",
        "          c <- zoo::coredata(x)\n",
        "\n",
        "          sequence <- seq(0, formation_period * num_formation_periods, formation_period)\n",
        "          starts <- (sequence + 1)[-(num_formation_periods+1)]\n",
        "          ends <- sequence[-1]\n",
        "\n",
        "          s <- sign(c[ends]-c[starts])\n",
        "          pos <- sum(s[s>0])\n",
        "          neg <- abs(sum(s[s<0]))\n",
        "\n",
        "          ratio <- ifelse(neg > 0, pos/neg, pos)\n",
        "          ratio\n",
        "        }\n",
        "      )\n",
        "    )\n",
        "}\n",
        "\n",
        "# snippet: function for calculating a momentum factor based on change over the formation period, normalised to the sum of the absolute differences v0.1\n",
        "#' Efficiency ratio factor\n",
        "#'\n",
        "#' The ratio of the change in the factor value over the formation period,\n",
        "#' normalised to the sum of the absolute differences of the factor value.\n",
        "#'\n",
        "#' @param prices_df dataframe of prices\n",
        "#' @param formation_period period over which to calculate the factor\n",
        "#' @param factor_col the column of prices_df over which to calculate factor\n",
        "#' @param ticker_col the column of prices_df containing the ticker names\n",
        "#'\n",
        "#' @return prices_df grouped by ticker with factor column\n",
        "#'\n",
        "#' @export\n",
        "#' @examples\n",
        "#' prices <- data.frame(\n",
        "#'   Ticker = rep(\"EURUSD\", 6),\n",
        "#'   Close = c(1.11567, 1.11609, 1.11823, 1.11990, 1.12056, 1.12161)\n",
        "#'   )\n",
        "#' efficiency_ratio_factor(prices, 3, 10)\n",
        "efficiency_ratio_factor <- function(prices_df, formation_period = 60, factor_col = Close, ticker_col = Ticker) {\n",
        "  factor_col <- dplyr::enquo(factor_col)\n",
        "  ticker_col <- dplyr::enquo(ticker_col)\n",
        "\n",
        "  # Calculate efficiency ratio factor\n",
        "  prices_df %>%\n",
        "    group_by(!!ticker_col) %>%\n",
        "    mutate(\n",
        "      factor = zoo::rollapplyr(\n",
        "        !!factor_col,\n",
        "        width = formation_period,\n",
        "        fill = NA,\n",
        "        FUN = function(x) {\n",
        "          change <- dplyr::last(x) - dplyr::first(x)\n",
        "          vola <- sum(abs(diff(x)[-1]))\n",
        "          er <- change/vola\n",
        "        }\n",
        "      )\n",
        "    )\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tIJp0T2xnFGl"
      },
      "source": [
        "## rw crypto load coinmetrics data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "shhb6hCBnJEn"
      },
      "source": [
        "prices <- rwRtools::crypto_get_coinmetrics(force_update = TRUE)\n",
        "prices %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7lz1xRgmCFtX"
      },
      "source": [
        "## rw crypto load ftx lending data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZerNuyz8CFGK"
      },
      "source": [
        "# snippet: rw crypto load ftx lending data v0.1\n",
        "lending_rates <- rwRtools::crypto_get_lending_rates()\n",
        "lending_rates %>%\n",
        "    head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jyrUyKUVELhN"
      },
      "source": [
        "## rw crypto load ftx futures"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dy7lUqNTEQpW"
      },
      "source": [
        "# snippet: rw crypto load ftx futures v0.1\n",
        "futures <- rwRtools::crypto_get_futures()\n",
        "futures %>%\n",
        "    head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gS_mKckaEfy1"
      },
      "source": [
        "## rw crypto load ftx index"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hPDWyjjZElrN"
      },
      "source": [
        "# snippet: rw crypto load ftx futures v0.1\n",
        "coin_index <- rwRtools::crypto_get_index()\n",
        "coin_index %>%\n",
        "    head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ELPGbksFnph6"
      },
      "source": [
        "## rw crypto load ftx perpetual funding rates"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "faCLWUPSn2rw"
      },
      "source": [
        "# snippet: rw crypto load ftx perpetual funding rates v0.1\n",
        "\n",
        "perp_rate <- rwRtools::crypto_get_perp_rates()\n",
        "perp_rate %>%\n",
        "    head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i3L7PZXCpLD1"
      },
      "source": [
        "## rw crypto load spot "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6_o99wQZpPfv"
      },
      "source": [
        "# snippet: load FTX spot data v0.1\n",
        "\n",
        "spot <- rwRtools::crypto_get_spot()\n",
        "spot %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M9RclJMeqOsc"
      },
      "source": [
        "## rw crypto load rebalance trades"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GCMpXDQ0qOKZ"
      },
      "source": [
        "# snippet: load FTX rebalance trades data v0.16\n",
        "\n",
        "rebal_trades <- rwRtools::crypto_get_rebalance_trades()\n",
        "rebal_trades %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mTazO_b7qtdq"
      },
      "source": [
        "## rw crypto load minute perpetuals"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zRh5mUW7quEB"
      },
      "source": [
        "# snippet: load FTX minute perpetuals data v0.16 - only contains data of minute perpetuals which are used as underlyings for leveraged tokens\n",
        "\n",
        "minute_perps <- rwRtools::crypto_get_minute_perpetuals()\n",
        "minute_perps %>%\n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vFpIhTQQZwk5"
      },
      "source": [
        "## rw crypto quickstart "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FDQfRtPWZ1il"
      },
      "source": [
        "# snippet: rw crypto quickstart v.0.1\n",
        "quicksetup(pod = \"Crypto\", path = \".\")\n",
        "prices %>% \n",
        "  head()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FzNH-r_kZ96V"
      },
      "source": [
        "## rw crypto calc periodic returns"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "INHiCUOEaCIT"
      },
      "source": [
        "# snippet: rw crypto calc periodic returns v.0.1\n",
        "# Calculate log and simple returns at the same periodicity as your data.\n",
        "# Assumes there are no gaps in your data and your price column is price_usd (as it is in default coinmetrics data) \n",
        "returns <- prices %>%\n",
        "  group_by(ticker) %>%\n",
        "  arrange(date) %>%\n",
        "  mutate(log_return = log(price_usd / lag(price_usd, n = 1))) %>%\n",
        "  mutate(simple_return = price_usd / lag(price_usd, n = 1) - 1) %>%\n",
        "  na.omit() %>%\n",
        "  ungroup()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MGTXp0j0aOrG"
      },
      "source": [
        "## rw crypto plot return histogram"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LV4Mn8BqbAYO"
      },
      "source": [
        "# snippet: rw crypto plot return histogram v.0.1\n",
        "returns %>%\n",
        "  filter(ticker %in% c('BTC','ETH','XRP')) %>%\n",
        "  ggplot(aes(x = log_return)) +\n",
        "    geom_histogram(position = 'identity', bins = 100) +\n",
        "    ggtitle('Distribution of Log Returns') +\n",
        "    facet_wrap(~ticker)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bVccrIqEgbYQ"
      },
      "source": [
        "# rw crypto plot return scatterplot"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BHIE3vS1gjQ4"
      },
      "source": [
        "# snippet: rw crypto plot return scatterplot\n",
        "# Just a simple example of creating a scatterplot\n",
        "returns %>%\n",
        "  filter(ticker %in% c('BTC','ETH','XRP')) %>%\n",
        "  mutate(lag_log_return = lag(log_return)) %>%\n",
        "  ggplot(aes(x = log_return, y = lag_log_return)) +\n",
        "    geom_point() +\n",
        "    ggtitle('Returns vs lagged returns') +\n",
        "    facet_wrap(~ticker)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8QjhI81paSXS"
      },
      "source": [
        "# rw crypto remove stablecoins"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_8pgcCqkaP7f"
      },
      "source": [
        "# snippet: rw crypto remove stablecoins v0.2\n",
        "# Remove stablecoins from data set\n",
        "prices <- prices %>% \n",
        "  filter(!ticker %in% c('BUSD','DAI','GUSD','HUSD','PAX','SAI','TUSD','USDC','USDK','USDT','USDT_ETH','USDT_OMNI','USDT_TRX', 'XAUT'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_vEjP4CNebFe"
      },
      "source": [
        "# rw crypto remove duplicates"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OT_roAajec1a"
      },
      "source": [
        "# snippet: rw crypto remove duplicates v0.1\n",
        "# Remove duplicate protocol coins from data set\n",
        "prices <- prices %>% \n",
        "  filter(!ticker %in% c('BNB_ETH','LEO_EOS','RENBTC', 'WNXM', 'WETH', 'WBTC'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j9uABlaLD7Wn"
      },
      "source": [
        "# rw crypto flag universe constituents"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_yp_4Vo0D7II"
      },
      "source": [
        "# snippet: rw crypto flag universe consituents v0.1\n",
        "create_universe <- function(prices, n=10, min_constituents = 10) {\n",
        "  # snippet: rw crypto remove stablecoins v0.2\n",
        "  # Remove stablecoins from data set\n",
        "  prices <- prices %>% \n",
        "    filter(!ticker %in% c('BUSD','DAI','GUSD','HUSD','PAX','SAI','TUSD','USDC','USDK','USDT','USDT_ETH','USDT_OMNI','USDT_TRX', 'XAUT')) \n",
        "  # snippet: rw crypto remove duplicates v0.1\n",
        "  # Remove duplicate protocol coins from data set\n",
        "  prices <- prices %>% \n",
        "    filter(!ticker %in% c('BNB_ETH','LEO_EOS','RENBTC', 'WNXM', 'WETH', 'WBTC'))\n",
        "\n",
        "  # Get first date where we have min_constituents\n",
        "  start_date <- prices %>%\n",
        "    group_by(date) %>%\n",
        "    summarise(count = n()) %>%\n",
        "    filter(count >= min_constituents) %>%\n",
        "    summarise(mindate = min(date)) %>%\n",
        "    pull(mindate)\n",
        "\n",
        "  # Flag universe consitutents\n",
        "  # For a given ticker/date observation, set is_index to TRUE if:\n",
        "  #    - the asset was in the top 10 coins by market cap the day before\n",
        "  #    - the date is on or after the date when we have min_consituents assets in our dataset\n",
        "  prices %>%\n",
        "    group_by(date) %>%\n",
        "    mutate(cap_rank = row_number(desc(market_cap))) %>%\n",
        "    arrange(date) %>%\n",
        "    group_by(ticker) %>%\n",
        "    mutate(is_index = lag(cap_rank) <= n & date >= '2015-04-01') %>%\n",
        "    na.omit() %>%\n",
        "    ungroup()\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# rw crypto get single market FTX data"
      ],
      "metadata": {
        "id": "LvLYPUWVFGe8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#' Get Single FTX Market v0.1\n",
        "#' \n",
        "#' @description Get market data for a single FTX market.\n",
        "#'\n",
        "#' @param market name of the market (string)\n",
        "#' @param resolution representing aggregation length in seconds (int)\n",
        "#' @param start_time human readable start time in UTC (string)\n",
        "#' @param end_time human readable end time in UTC (string)\n",
        "#'\n",
        "#' @return dataframe of prices if API call was successful, otherwise call result\n",
        "#' @export\n",
        "#'\n",
        "#' @examples\n",
        "#' get_single_ftx_market(\"BTC-PERP\", resolution = 86400, start_time = \"2019-07-20\", end_time = \"2022-06-30)\n",
        "get_single_ftx_market <- function(market, resolution = 86400, start_time = \"2019-07-20\", end_time = \"2022-06-30\") {\n",
        "  endpoint <- \"https://ftx.com/api\"\n",
        "  start_time <- as.numeric(as.POSIXct(start_time, tz = \"UTC\"))\n",
        "  end_time <- as.numeric(as.POSIXct(end_time, tz = \"UTC\"))\n",
        "  \n",
        "  res <- httr::GET(glue::glue(\"{endpoint}/markets/{market}/candles?resolution={resolution}&start_time={start_time}&end_time={end_time}\")) \n",
        "  \n",
        "  res_json <- res$content %>% \n",
        "    rawToChar() %>% \n",
        "    jsonlite::fromJSON()\n",
        "  \n",
        "  if(res_json$success == TRUE) {\n",
        "    prices <- res_json %>% \n",
        "      purrr::pluck(\"result\") %>% \n",
        "      dplyr::mutate(datetime = lubridate::as_datetime(startTime)) %>% \n",
        "      dplyr::select(-startTime, -time)\n",
        "    \n",
        "    return(prices)\n",
        "  } else {\n",
        "    print(\"Request failed.\")\n",
        "    \n",
        "    return(res_json)\n",
        "  }\n",
        "}"
      ],
      "metadata": {
        "id": "62tn8dHFFHHO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# rw crypto get multiple FTX market data"
      ],
      "metadata": {
        "id": "rxMPHTgSFHOL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#' Get Multiple FTX Markets v0.1\n",
        "#' \n",
        "#' @description Get market data for multipole FTX markets.\n",
        "#'\n",
        "#' @param market name of the markets (vector of string)\n",
        "#' @param resolution representing aggregation length in seconds (int)\n",
        "#' @param start_time human readable start time in UTC (string)\n",
        "#' @param end_time human readable end time in UTC (string)\n",
        "#'\n",
        "#' @return dataframe of prices if API call was successful, otherwise call result\n",
        "#' @export\n",
        "#'\n",
        "#' @examples\n",
        "#' get_multiple_ftx_markets(c(\"BTC-PERP\", \"ETH-PERP\"), resolution = 86400, start_time = \"2019-07-20\", end_time = \"2022-06-30)\n",
        "get_multiple_ftx_markets <- function(markets, resolution = 86400, start_time = \"2019-07-20\", end_time = \"2022-06-30\") {\n",
        "  prices <- data.frame()\n",
        "  for(market in markets) {\n",
        "    these_prices <- get_single_ftx_market(market, resolution = resolution, start_time = start_time, end_time = end_time)\n",
        "    if(!is.null(these_prices)) {\n",
        "      these_prices <- these_prices %>% \n",
        "        dplyr::mutate(ticker = market)\n",
        "      \n",
        "      prices <- dplyr::bind_rows(prices, these_prices)\n",
        "    } else {\n",
        "      print(glue(\"Failed to get data for market {market}\"))\n",
        "    }\n",
        "  }\n",
        "    \n",
        "    prices\n",
        "}"
      ],
      "metadata": {
        "id": "5GpNVKfDFHWT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c_dCf_f2vGkQ"
      },
      "source": [
        "# rw macro quickstart"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8zuTwvycvFoF"
      },
      "source": [
        "# snippet: rw macro quickstart v.0.1\n",
        "quicksetup(pod = \"Macro\", path = \".\")\n",
        "prices %>% \n",
        "  head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# rw macro calculate ewma of a vector"
      ],
      "metadata": {
        "id": "0It-ignTuj1p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# function for calculating the ewma of a vector v0.1\n",
        "ewma <- function(x, lambda) {\n",
        "  ewma = vector(mode = \"double\", length = length(x))\n",
        "  ewma[1] = x[1]\n",
        "  for(i in 2:length(x)) {\n",
        "    ewma[i]  = (1 - lambda)*x[i] + lambda*ewma[i-1]\n",
        "  }\n",
        "  ewma\n",
        "}"
      ],
      "metadata": {
        "id": "JC87UTUKuaBt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# rw macro calculate exponentially weighted covariance estimate"
      ],
      "metadata": {
        "id": "al81QDK5uxgm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# EWMA covariance estimate v0.1\n",
        "# TODO: should probably drop a number of observations at the front while the EWMA warms up\n",
        "# Note updated definition of lambda in line with Risk Metrics\n",
        "# ie higher values of lambda put less weight on the most recent returns and more weight on historical returns.\n",
        "\n",
        "ewma_cov <- function(x, y, lambda, initialisation_wdw = 100) {\n",
        "  # TODO: \n",
        "    # check that x and y are the same length and greater than initialisation_wdw\n",
        "    # check NA removed\n",
        "  \n",
        "  # create initialisation window and estimation window\n",
        "  init_x = x[1:initialisation_wdw]\n",
        "  init_y = y[1:initialisation_wdw]\n",
        "\n",
        "  num_obs <- length(x)\n",
        "  \n",
        "  # initial covariance and mean return estimates\n",
        "  old_cov <- cov(init_x, init_y)\n",
        "  old_x <- mean(init_x)\n",
        "  old_y <- mean(init_y)\n",
        "  \n",
        "  # preallocate output vector\n",
        "  ewma_cov <- vector(mode = \"numeric\", length = num_obs)\n",
        "\n",
        "  # pad with NA for initialisation window\n",
        "  ewma_cov[1:initialisation_wdw] <- NA\n",
        "  \n",
        "  # covariance estimate\n",
        "  for(i in c((initialisation_wdw+1):num_obs)) { \n",
        "    ewma_cov[i] <- lambda*old_cov + (1 - lambda)*(old_x * old_y)\n",
        "    old_cov <- ewma_cov[i]\n",
        "    old_x <- x[i]\n",
        "    old_y <- y[i]\n",
        "  }\n",
        "  ewma_cov\n",
        "}"
      ],
      "metadata": {
        "id": "K9Fbl_JMu2Fh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# rw macro exponentially weighted correlation estimate"
      ],
      "metadata": {
        "id": "iLaxjQEtu8Zt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# EWMA correlation estimate v0.1\n",
        "# TODO: should probably drop a number of observations at the front while the EWMA warms up\n",
        "# Note updated definition of lambda in line with Risk Metrics\n",
        "# ie higher values of lambda put less weight on the most recent returns and more weight on historical returns.\n",
        "\n",
        "# Approach is as follows:\n",
        "  # Calculate ewma covariance as we did previously\n",
        "  # Calculate ewma asset-wise variance estimates\n",
        "  # Correlation estimate is cov/(sqrt(var1)*sqrt(var2))\n",
        "\n",
        "ewma_cor <- function(x, y, lambda, initialisation_wdw = 100) {\n",
        "  # TODO: \n",
        "    # check that x and y are the same length and greater than initialisation_wdw\n",
        "    # check NA removed\n",
        "    # check lambda between 0 and 1\n",
        "  \n",
        "  # create initialisation window and estimation window\n",
        "  init_x = x[1:initialisation_wdw]\n",
        "  init_y = y[1:initialisation_wdw]\n",
        "\n",
        "  num_obs <- length(x)\n",
        "  \n",
        "  # initial covariance, variance, and mean return estimates\n",
        "  old_cov <- cov(init_x, init_y)\n",
        "  old_var_x <- var(init_x)\n",
        "  old_var_y <- var(init_y)\n",
        "  old_x <- mean(init_x)\n",
        "  old_y <- mean(init_y)\n",
        "  \n",
        "  # preallocate output vector\n",
        "  ewma_cor <- vector(mode = \"numeric\", length = num_obs)\n",
        "\n",
        "  # pad with NA for initialisation window\n",
        "  ewma_cor[1:initialisation_wdw] <- NA\n",
        "  \n",
        "  # correlation estimate from ewma covariance and variances\n",
        "  # use superfluous temporary variables to make the sequence of steps explicit\n",
        "  for(i in c((initialisation_wdw+1):num_obs)) { \n",
        "    # cov estimate\n",
        "    this_cov <- lambda*old_cov + (1 - lambda)*(old_x * old_y)\n",
        "    # var estimates\n",
        "    this_var_x <- lambda * old_var_x + (1 - lambda) * old_x^2\n",
        "    this_var_y <- lambda * old_var_y + (1 - lambda) * old_y^2\n",
        "    # correlation estimate\n",
        "    ewma_cor[i] <- this_cov / (sqrt(this_var_x) * sqrt(this_var_y))\n",
        "    \n",
        "    # update values\n",
        "    old_cov <- this_cov\n",
        "    old_var_x <- this_var_x\n",
        "    old_var_y <- this_var_y\n",
        "    old_x <- x[i]\n",
        "    old_y <- y[i]\n",
        "  }\n",
        "  ewma_cor\n",
        "}"
      ],
      "metadata": {
        "id": "4bprjk4Eu_ob"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# rw macro recover correlation matrix"
      ],
      "metadata": {
        "id": "pHSyZ-v0vbbm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# function for recovering corrmat from long correlation dataframe v0.1\n",
        "recover_cormat <- function(long_cors, tickers, num_assets) {\n",
        "  cor_mat <- matrix(rep(0, num_assets*num_assets), num_assets)\n",
        "  dimnames(cor_mat) <- list(tickers, tickers)\n",
        "\n",
        "  # recover lower triangle and diagonal\n",
        "  cor_mat[lower.tri(cor_mat, diag = TRUE)] <- long_cors$ewma_cor\n",
        "\n",
        "  # recover upper triangle as upper triangle of transpose of half-formed matrix\n",
        "  cor_mat[upper.tri(cor_mat)] <- t(cor_mat)[upper.tri(cor_mat)]\n",
        "\n",
        "  cor_mat\n",
        "}"
      ],
      "metadata": {
        "id": "y1BdOxhWvecE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ONa2WGLFwiQj"
      },
      "source": [
        "# rw set plot options\n",
        "\n",
        "Sets plot dimensions and text size to something that renders nicely in GitHub. \n",
        "\n",
        "Sets `ggplot` theme to `theme_bw`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k0cSwXECwiY_"
      },
      "source": [
        "# snippet: re set plot options v0.1\n",
        "options(repr.plot.width = 14, repr.plot.height=7)\n",
        "theme_set(theme_bw())\n",
        "theme_update(text = element_text(size = 20))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aRbzRpWIjrhZ"
      },
      "source": [
        "# rw calculate bar TWAP"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XHQVpt1Ejqkv"
      },
      "source": [
        "# snippet: rw calculate bar TWAP v0.1\n",
        "TWAP <- function(open, high, low, close) {\n",
        "  OC_dist <- abs(close - open)\n",
        "  OH_dist <- (high - open)\n",
        "  OL_dist <- (open - low)\n",
        "  HL_dist <- (high - low)\n",
        "  LC_dist <- (close - low)\n",
        "  HC_dist <- (high - close)\n",
        "  \n",
        "  OHLC_dist <- OH_dist + HL_dist + LC_dist\n",
        "  OLHC_dist <- OL_dist + HL_dist + HC_dist\n",
        "  \n",
        "  OH_mean <- (open + high) * 0.5\n",
        "  OL_mean <- (open + low) * 0.5\n",
        "  HL_mean <- (high + low) * 0.5\n",
        "  LC_mean <- (low + close) * 0.5\n",
        "  HC_mean <- (high + close) * 0.5\n",
        "  \n",
        "  OHLC_twap <-  (((OH_dist / OHLC_dist) * OH_mean) + ((HL_dist / OHLC_dist) * HL_mean) + ((LC_dist / OHLC_dist) * LC_mean))\n",
        "  OLHC_twap <-  (((OL_dist / OLHC_dist) * OL_mean) + ((HL_dist / OLHC_dist) * HL_mean) + ((HC_dist / OLHC_dist) * HC_mean))\n",
        "  \n",
        "  TWAP <- ifelse(OHLC_dist == 0, close, (OHLC_twap + OLHC_twap) * 0.5)\n",
        " \n",
        "  return(TWAP)\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "fbxE54NI3FkT"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}