final_report.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary of Cycle Indicators\n",
    "## Derivative Department, Egret Asset\n",
    "### Jan. 6th - April. 5th\n",
    "李心怡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I. Filters\n",
    "First we define some filters that might be useful in understanding indicators. (Although some are just for completeness, and ware never used by any indicators here.)\n",
    "### Simple Moving Average (4 period)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sma4(series):\n",
    "    \"\"\"\n",
    "    4 term simple moving average\n",
    "    :param series: (np.array) price\n",
    "    :return: (np.array) smoothed price\n",
    "    \"\"\"\n",
    "    newseries = (series + 2 * np.roll(series, 1) + 2 * np.roll(series, 2)\n",
    "                 + np.roll(series, 3)) / 6\n",
    "    newseries[:3] = series[:3]\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exponencial Moving Average\n",
    "cutoff $(0, +\\infty)$: for wave that has a period less than the cutoff period (i.e higher frequency part), its power is lessened to 1/2 or more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ema(series, cutoff):\n",
    "    \"\"\"\n",
    "    exponential moving average\n",
    "    alpha = 1/(lag+1)\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (float) cutoff period of the filter\n",
    "    :return: (np.array) filtered price\n",
    "    \"\"\"\n",
    "    K = 1\n",
    "    alpha = 1 + (np.sin(2 * np.pi * K / cutoff) - 1) / np.cos(2 * np.pi * K / cutoff)\n",
    "    for i in range(1, series.shape[0]):\n",
    "        series[i] = alpha * series[i] \\\n",
    "                    + (1 - alpha) * series[i - 1]\n",
    "    return series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regularized EMA\n",
    "cutoff $(0, +\\infty)$: for wave that has a period less than the cutoff period (i.e higher frequency part), its power is lessened to 1/2 or more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def regularized_ema(series, cutoff):\n",
    "    \"\"\"\n",
    "    add an additional penalty term to enhance filter effect while introducing no more lag\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (float) cutoff period of the filter\n",
    "    :return: (np.array) filtered price\n",
    "    \"\"\"\n",
    "    K = 1\n",
    "    alpha = 1 + (np.sin(2 * np.pi * K / cutoff) - 1) / np.cos(2 * np.pi * K / cutoff)\n",
    "    l = np.exp(0.16 / alpha)\n",
    "    newseries = np.copy(series)\n",
    "    for i in range(2, series.shape[0]):\n",
    "        newseries[i] = alpha / (1 + l) * series[i] \\\n",
    "                       + (1 - alpha - 2 * l) / (1 + l) * newseries[i - 1] - l / (l + 1) * newseries[i - 2]\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lowpass Filter 2 poles\n",
    "cutoff $(0, +\\infty)$: for wave that has a period less than the cutoff period (i.e higher frequency part), its power is lessened to 1/2 or more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lowpass2pole(series, cutoff):\n",
    "    \"\"\"\n",
    "    2 pole low-pass filter\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (float) cutoff period of the filter\n",
    "    :return: (np.array) filtered price\n",
    "    \"\"\"\n",
    "    K = 1.414\n",
    "    alpha = 1 + (np.sin(2 * np.pi * K / cutoff) - 1) / np.cos(2 * np.pi * K / cutoff)\n",
    "    for i in range(2, series.shape[0]):\n",
    "        series[i] = alpha ** 2 * series[i] \\\n",
    "                    + 2 * (1 - alpha) * series[i - 1] + (1 - alpha) ** 2 * series[i - 2]\n",
    "    return series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decycler\n",
    "= 1 - highpass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decycler(series, cutoff):\n",
    "    \"\"\"\n",
    "    subtract high frequency component from the original series to decycle\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (float) cutoff period of the filter\n",
    "    :return: (np.array) decycled series\n",
    "    \"\"\"\n",
    "    K = 1\n",
    "    alpha = 1 + (np.sin(2 * np.pi * K / cutoff) - 1) / np.cos(2 * np.pi * K / cutoff)\n",
    "    newseries = np.copy(series)\n",
    "    for i in range(1, series.shape[0]):\n",
    "        newseries[i] = alpha / 2 * (series[i] + series[i - 1]) \\\n",
    "                       + (1 - alpha) * newseries[i - 1]\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Highpass Filter\n",
    "cutoff $(0, +\\infty)$: for wave that has a period greater than the cutoff period (i.e lower frequency part), its power is lessened to 1/2 or more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def highpass(series, cutoff):\n",
    "    \"\"\"\n",
    "    (1 pole) high-pass filter\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (float) cutoff period of the filter\n",
    "    :return: (np.array) filtered price\n",
    "    \"\"\"\n",
    "    K = 1\n",
    "    alpha = 1 + (np.sin(2 * np.pi * K / cutoff) - 1) / np.cos(2 * np.pi * K / cutoff)\n",
    "    newseries = np.copy(series)\n",
    "    for i in range(1, series.shape[0]):\n",
    "        newseries[i] = (1 - alpha / 2) * series[i] - (1 - alpha / 2) * series[i - 1] \\\n",
    "                       + (1 - alpha) * newseries[i - 1]\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Highpass Filter 2 poles\n",
    "cutoff $(0, +\\infty)$: for wave that has a period greater than the cutoff period (i.e lower frequency part), its power is lessened to 1/2 or more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def highpass2pole(series, cutoff):\n",
    "    \"\"\"\n",
    "    2 pole high-pass filter\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (float) cutoff period of the filter\n",
    "    :return: (np.array) filtered price\n",
    "    \"\"\"\n",
    "    K = 0.707\n",
    "    alpha = 1 + (np.sin(2 * np.pi * K / cutoff) - 1) / np.cos(2 * np.pi * K / cutoff)\n",
    "    newseries = np.copy(series)\n",
    "    for i in range(2, series.shape[0]):\n",
    "        newseries[i] = (1 - alpha / 2) ** 2 * series[i] \\\n",
    "                       - 2 * (1 - alpha / 2) ** 2 * series[i - 1] \\\n",
    "                       + (1 - alpha / 2) ** 2 * series[i - 2] \\\n",
    "                       + 2 * (1 - alpha) * newseries[i - 1] - (1 - alpha) ** 2 * newseries[i - 2]\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Super Smoother 2 poles\n",
    "cutoff $(0, +\\infty)$: for wave that has a period less than the cutoff period (i.e higher frequency part), its power is lessened to 1/2 or more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def supersmoother2pole(series, cutoff):\n",
    "    \"\"\"\n",
    "    simplified 2 pole butterworth smoother\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (float) cutoff period of the filter\n",
    "    :return: (np.array) smoothed price\n",
    "    \"\"\"\n",
    "    a = np.exp(-1.414 * np.pi / cutoff)\n",
    "    b = 2 * a * np.cos(1.414 * np.pi / cutoff)\n",
    "    newseries = np.copy(series)\n",
    "    for i in range(2, series.shape[0]):\n",
    "        newseries[i] = (1 + a ** 2 - b) / 2 * (series[i] + series[i - 1]) \\\n",
    "                       + b * newseries[i - 1] - a ** 2 * newseries[i - 2]\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Super Smoother 3 poles\n",
    "cutoff $(0, +\\infty)$: for wave that has a period less than the cutoff period (i.e higher frequency part), its power is lessened to 1/2 or more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def supersmoother3pole(series, cutoff):\n",
    "    \"\"\"\n",
    "    simplified 3 pole butterworth smoother\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (float) cutoff period of the filter\n",
    "    :return: (np.array) smoothed price\n",
    "    \"\"\"\n",
    "    a = np.exp(-np.pi / cutoff)\n",
    "    b = 2 * a * np.cos(1.738 * np.pi / cutoff)\n",
    "    c = a ** 2\n",
    "    newseries = np.copy(series)\n",
    "    for i in range(3, series.shape[0]):\n",
    "        newseries[i] = (1 - c ** 2 - b + b * c) * series[i] \\\n",
    "                       + (b + c) * newseries[i - 1] + (-c - b * c) * newseries[i - 2] + (c ** 2) * newseries[i - 3]\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Allpass filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def allpass(series, alpha):\n",
    "    \"\"\"\n",
    "    allpass filter (used in laguerre filter)\n",
    "    :param series: (np.array) price\n",
    "    :param alpha: (float) damping factor\n",
    "    :return: (np.array) filtered price\n",
    "    \"\"\"\n",
    "    newseries = np.copy(series)\n",
    "    for i in range(1, series.shape[0]):\n",
    "        newseries[i] = -alpha * series[i] + series[i - 1] \\\n",
    "                       + alpha * newseries[i - 1]\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Laguerre filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laguerre(series, gamma):\n",
    "    \"\"\"\n",
    "    Laguerre filter\n",
    "    :param series: (np.array) price\n",
    "    :param gamma: (float) damping factor\n",
    "    :return: (np.array) filtered price\n",
    "    \"\"\"\n",
    "    l0 = ema(series, gamma)\n",
    "    l1 = allpass(l0, gamma)\n",
    "    l2 = allpass(l1, gamma)\n",
    "    l3 = allpass(l2, gamma)\n",
    "    return l0, l1, l2, l3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Roofing Filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def roofing(series, cutoff_hp, cutoff_lp):\n",
    "    \"\"\"\n",
    "    roofing filter\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff_hp: (np.array) cutoff period for highpass filter\n",
    "    :param cutoff_lp: (np.array) cutoff period for lowpass filter\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    hp = highpass2pole(series, cutoff_hp)\n",
    "    newseries = supersmoother3pole(hp, cutoff_lp)\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adaptive highpass filter 2 poles\n",
    "This filter is written for adaptive methods. It takes a series of lag rather than one constant lag as parameter. This input lag series is computed with other methods which approximate the dominant cycle period of the data, such as Hilbert Transformation method for computing period."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ad_highpass2pole(series, lag):\n",
    "    \"\"\"\n",
    "    2 pole adaptive high-pass filter (variable cutoff period)\n",
    "    :param series: (np.array) price\n",
    "    :param lag: (np.array) lag of the filter\n",
    "    :return: (np.array) filtered price\n",
    "    \"\"\"\n",
    "    alpha = 1 / (1 + lag)\n",
    "    newseries = np.copy(series)\n",
    "    for i in range(2, series.shape[0]):\n",
    "        newseries[i] = (1 - alpha[i] / 2) ** 2 * series[i] \\\n",
    "                       - 2 * (1 - alpha[i] / 2) ** 2 * series[i - 1] \\\n",
    "                       + (1 - alpha[i] / 2) ** 2 * series[i - 2] \\\n",
    "                       + 2 * (1 - alpha[i]) * newseries[i - 1] - (1 - alpha[i]) ** 2 * newseries[i - 2]\n",
    "    return newseries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## II. Indicator Transformer\n",
    "### Stochasticize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stoch(series, period):\n",
    "    \"\"\"\n",
    "    stochaticize the indicator\n",
    "    :param series: (np.array) indicator or price\n",
    "    :param period: (int) window length\n",
    "    :return: (np.array) series of value within [0,1]\n",
    "    \"\"\"\n",
    "    df = pd.Series(series)\n",
    "    df_max = df.rolling(period, min_periods=1).max()\n",
    "    df_min = df.rolling(period, min_periods=1).min()\n",
    "    series = (df - df_min) / (df_max - df_min)\n",
    "    return series.to_numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fisher Transformer\n",
    "normalize indicators so that it satisfies statistic inference of normally distributed data\n",
    "\n",
    "period $(0, +\\infty)$: window length for applying fisher transformation and stochasticize\n",
    "\n",
    "stoch_time $(0, +\\infty)$: number of time applying stochastic transformation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fisher(series, period, stoch_time):\n",
    "    \"\"\"\n",
    "    fisher transformer\n",
    "    :param series: (np.array) indicator or price\n",
    "    :param period: (int) window length\n",
    "    :param stoch_time: (int) number of time applying stochastic transformation\n",
    "    :return: (np.array) normalized series satisfying statistic inference of normally distributed data\n",
    "    \"\"\"\n",
    "    # stochaticize\n",
    "    for i in range(stoch_time):\n",
    "        series = stoch(series, period)\n",
    "    # transform data to [-0.9999,0.9999]\n",
    "    series = 2 * (series - 0.5)\n",
    "    for i in range(series.shape[0]):\n",
    "        series[i] = max(-0.9999, min(0.9999, series[i]))\n",
    "    # apply fisher transformation\n",
    "    series = np.log((1 + series) / (1 - series)) / 2\n",
    "    return series"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## III. Method for computing period\n",
    "According to my observation, this approximation is not a very good one and is rather unstable. So the indicators that based on it -- Adaptive Momentum, Adaptive CCI etc. -- are also unreliable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hilbert(series):\n",
    "    \"\"\"\n",
    "    Hilbert transformation\n",
    "    :param series: (np.array) price\n",
    "    :return: (np.array) InPhase and Quadrature term\n",
    "    \"\"\"\n",
    "    Q = 0.0962 * series + 0.5796 * np.roll(series, 2) \\\n",
    "        - 0.5796 * np.roll(series, 4) - 0.0962 * np.roll(series, 6)\n",
    "    Q[0:6] = 0\n",
    "    I = np.roll(series, 3)\n",
    "    I[0:3] = 0\n",
    "    return Q, I\n",
    "\n",
    "\n",
    "def compute_period(series, cutoff):\n",
    "    \"\"\"\n",
    "    use hilbert transformation to compute period for adaptive methods\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (np.array) cutoff period for highpass filter\n",
    "    :return: (np.array) period and cycle\n",
    "    \"\"\"\n",
    "    smooth = sma4(series)\n",
    "    cycle = highpass2pole(smooth, cutoff)\n",
    "    for i in range(2, 7):\n",
    "        cycle[i] = (series[i] - 2 * series[i - 1] + series[i - 2]) / 4\n",
    "    delta_phase = np.zeros_like(series)\n",
    "    inst_period = np.zeros_like(series)\n",
    "    period = np.zeros_like(series)\n",
    "    Q, I = hilbert(cycle)\n",
    "    for i in range(6, series.shape[0]):\n",
    "        Q[i] *= 0.5 + 0.08 * inst_period[i - 1]\n",
    "        if Q[i] != 0 and Q[i - 1] != 0:\n",
    "            delta_phase[i] = (I[i] / Q[i] - I[i - 1] / Q[i - 1]) / (1 + I[i] * I[i - 1] / (Q[i] * Q[i - 1]))\n",
    "            delta_phase[i] = max(0.1, min(1.1, delta_phase[i]))\n",
    "        median_delta = np.median(delta_phase[i - 4:i + 1])\n",
    "        if median_delta == 0:\n",
    "            DC = 15\n",
    "        else:\n",
    "            DC = 6.29318 / median_delta + 0.5\n",
    "        inst_period[i] = 0.33 * DC + 0.67 * inst_period[i - 1]\n",
    "        period[i] = 0.15 * inst_period[i] + 0.85 * period[i - 1]\n",
    "    return period, cycle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IV. Trend Indicator\n",
    "### Instantaneous Trendline\n",
    "\n",
    "1) **method**\n",
    "    \n",
    "Use a highpass (2 poles) filter to smooth the price series.\n",
    "\n",
    "Note: The first 7 price is computed separately by a SMA4 to reduce the influence of lack of samples at the beginning of the series, however in our case it is rather unnecessary because ① we have a initial period for contract to avoid this influence and ② the number 7 needs to be tailored for our situation as the book uses daily price input.\n",
    "    \n",
    "2) **parameter range**\n",
    "    \n",
    "* cutoff $(0, +\\infty)$: cutoff period of hp\n",
    "    \n",
    "3) **trading strategy**\n",
    "    \n",
    "$trigger = 2 * trend - lag\\_trend$\n",
    "\n",
    "Buy when trigger is above trend, short otherwise   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def i_trend(series, cutoff):\n",
    "    \"\"\"\n",
    "    instantaneous trendline\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff: (float) cutoff period of the hp\n",
    "    :return: (np.array) trend and its trigger\n",
    "    \"\"\"\n",
    "    # compute inst trend\n",
    "    K = 0.707\n",
    "    alpha = 1 + (np.sin(2 * np.pi * K / cutoff) - 1) / np.cos(2 * np.pi * K / cutoff)\n",
    "    it = np.copy(series)\n",
    "    for i in range(2, 7):\n",
    "        it[i] = (series[i] + 2 * series[i - 1] + series[i - 2]) / 4\n",
    "    for i in range(7, series.shape[0]):\n",
    "        it[i] = (alpha - alpha ** 2 / 4) * series[i] \\\n",
    "                + alpha ** 2 / 2 * series[i - 1] \\\n",
    "                - (alpha - alpha ** 2 * 3 / 4) * series[i - 2] \\\n",
    "                + 2 * (1 - alpha) * it[i - 1] - (1 - alpha) ** 2 * it[i - 2]\n",
    "\n",
    "    # compute lead 2 trigger & signal\n",
    "    lag2 = np.roll(it, 20)\n",
    "    lag2[:20] = it[:20]\n",
    "    trigger = 2 * it - lag2\n",
    "    return it, trigger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Smoothed Adaptive Monmentum Indicator\n",
    "\n",
    "1) **method**\n",
    "\n",
    "compare the price in the current cycle with that in the previous cycle (same phase) to indicate an uptrend or downtrend\n",
    "\n",
    "2) **parameter range**\n",
    "    \n",
    "* cutoff_period $(0, +\\infty)$: the cutoff period used to compute the period using Hilbert Transformation\n",
    "\n",
    "* cutoff_signal $(0, +\\infty)$: the cutoff period used to smooth the signal\n",
    "    \n",
    "3) **trading strategy**\n",
    "    \n",
    "Buy when the smoothed signal is above 0 (in a uptrend), short otherwise. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ad_momentum(series, cutoff_period, cutoff_signal):\n",
    "    \"\"\"\n",
    "    smoothed adaptive momentum indicator\n",
    "    compare the price in the current cycle with that in the previous cycle (same phase)\n",
    "    to indicate an uptrend or downtrend\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff_period: (float) the cutoff period used to compute the period using Hilbert Transformation\n",
    "    :param cutoff_signal: (float) the cutoff period used to smooth the signal\n",
    "    :return: (np.array) momentum\n",
    "    \"\"\"\n",
    "    period, _ = compute_period(series, cutoff_period)\n",
    "    period = period.astype(np.int)\n",
    "    momen = np.zeros_like(series)\n",
    "    for i in range(series.shape[0]):\n",
    "        if (i - period[i]) >= 0:\n",
    "            momen[i] = series[i] - series[i - period[i]]\n",
    "    momen = supersmoother3pole(momen, cutoff_signal)\n",
    "    return momen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## V. Oscillator\n",
    "### Decycler Oscillator\n",
    "\n",
    "1) **method**\n",
    "    \n",
    "take the difference of 2 decyclers (highpass filters) with different cutoff to get the cycle\n",
    "    \n",
    "2) **parameter range**\n",
    "    \n",
    "* cutoff1 $(0, +\\infty)$: cutoff period of the first highpass filter\n",
    "\n",
    "* times $(1, +\\infty)$: $\\frac{\\text{cutoff period of the second highpass filter}}{\\text{cutoff period of the first highpass filter}}$\n",
    "\n",
    "3) **trading strategy**\n",
    "    \n",
    "Buy when above 0 (in a uptrend), short otherwise.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decycler_oscillator(series, cutoff1, times):\n",
    "    \"\"\"\n",
    "    decycler oscillator\n",
    "    take the difference of 2 decyclers with different cutoff\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff1: (float) the smaller cutoff period\n",
    "    :param times: (float, >1) larger cutoff / smaller cutoff\n",
    "    :return: (np.array) indicator\n",
    "    \"\"\"\n",
    "    cutoff2 = cutoff1 * times\n",
    "    hp1 = highpass(series, cutoff1)\n",
    "    hp2 = highpass(series, cutoff2)\n",
    "    delta_hp = hp2 - hp1\n",
    "    # >0: uptrend, <0: downtrend\n",
    "    return delta_hp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bandpass Filter\n",
    "\n",
    "1) **method**\n",
    "    \n",
    "* use a highpass filter to avoid spectral dilation\n",
    "\n",
    "* pass a bandpass filter\n",
    "\n",
    "* use \"fast attack-slow decay\" approach to normalize the indicator to $[-1, 1]$\n",
    "    \n",
    "2) **parameter range**\n",
    "    \n",
    "* cycle $(0, +\\infty)$: center of the bandpass period\n",
    "\n",
    "* bandwidth $(0, 2)$: $\\frac{\\text{bandwidth (in period)}}{\\text{cycle}}$\n",
    "\n",
    "3) **trading strategy**\n",
    "    \n",
    "Trigger line is created by pass the bandpass result through another highpass filter.\n",
    "\n",
    "Buy when the trigger crosses over the bandpass result, short when crosses under."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bandpass(series, cycle, bandwidth):\n",
    "    \"\"\"\n",
    "    bandpass filter\n",
    "    :param series: (np.array) price\n",
    "    :param cycle: (float) cycle period\n",
    "    :param bandwidth: (float, >0 <2) length between left and right cutoffs / cycle period\n",
    "    :return: (np.array) indicator\n",
    "    \"\"\"\n",
    "    # pass a HP to avoid spectral dilation of BP\n",
    "    hp = highpass(series, 4 * cycle / bandwidth)\n",
    "    # bandpass filter\n",
    "    lmd = np.cos(2 * np.pi / cycle)\n",
    "    gamma = np.cos(2 * np.pi * bandwidth / cycle)\n",
    "    sigma = 1 / gamma - np.sqrt(1 / gamma ** 2 - 1)\n",
    "    bp = np.copy(hp)\n",
    "    for i in range(2, series.shape[0]):\n",
    "        bp[i] = (1 - sigma) / 2 * hp[i] - (1 - sigma) / 2 * hp[i - 2] \\\n",
    "                + lmd * (1 + sigma) * bp[i - 1] - sigma * bp[i - 2]\n",
    "    # fast attack-slow decay AGC\n",
    "    K = 0.991\n",
    "    peak = np.copy(bp)\n",
    "    for i in range(series.shape[0]):\n",
    "        if i > 0:\n",
    "            peak[i] = peak[i - 1] * K\n",
    "        if abs(bp[i]) > peak[i]:\n",
    "            peak[i] = abs(bp[i])\n",
    "    bp_normalized = bp / peak\n",
    "    bp_normalized[np.isnan(bp_normalized)] = 0\n",
    "    # trigger(lead) & signal\n",
    "    trigger = highpass(bp_normalized, cycle / bandwidth / 1.5)\n",
    "    return bp, bp_normalized, trigger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cyber Cycle Index\n",
    "\n",
    "1) **method**\n",
    "    \n",
    "* smooth the price with SMA4\n",
    "\n",
    "* pass a highpass (2 poles) filter\n",
    "\n",
    "* smooth the cycle with EMA\n",
    "    \n",
    "2) **parameter range**\n",
    "    \n",
    "* cutoff1 $(0, +\\infty)$: cutoff period for highpass filter\n",
    "\n",
    "* cutoff2 $(0, +\\infty)$: cutoff period for EMA filter\n",
    "\n",
    "* fperiod, stoch_time: same as fisher transformation parameters\n",
    "\n",
    "3) **trading strategy**\n",
    "    \n",
    "Buy when signal crosses under lag1, sell when signal crosses over lag1.\n",
    "\n",
    "Also, it requires a 'stop loss' strategy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cci(series, cutoff1, cutoff2, fperiod=None, stoch_time=None):\n",
    "    \"\"\"\n",
    "    CCI - cyber cycle index\n",
    "    delay is less than half a cycle: buy when signal cross under lag1, sell when signal cross over lag1\n",
    "    need a 'stop loss' strategy, close out when profit<0 and bars since entry > 8(period)\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff1: (float) cutoff period for hp\n",
    "    :param cutoff2: (float) cutoff period for ema\n",
    "    :param fperiod, stoch_time: (tuple: ((int)period, (int)stoch_time)) fisher transformation parameters\n",
    "    :return: (np.array) cycle\n",
    "    \"\"\"\n",
    "    # compute the cycle\n",
    "    smooth = sma4(series)\n",
    "    cycle = highpass2pole(smooth, cutoff1)\n",
    "    for t in range(2, 7):\n",
    "        cycle[t] = (series[t] - 2 * series[t - 1] + series[t - 2]) / 4\n",
    "    signal = ema(cycle, cutoff2)\n",
    "    # apply fisher transformation\n",
    "    if fperiod != None:\n",
    "        signal = fisher(signal, fperiod, stoch_time)\n",
    "    return signal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### center of gravity\n",
    "1) **method**\n",
    "    \n",
    "View the price as weight to compute the center of gravity of the filter. If the center of gravity is closer to today relative to today minus the window length, it suggests that price is higher / moving upward recently.\n",
    "    \n",
    "2) **parameter range**\n",
    "    \n",
    "* length $(0, +\\infty)$: window length\n",
    "\n",
    "* fperiod, stoch_time: same as fisher transformation parameters\n",
    "\n",
    "3) **trading strategy**\n",
    "    \n",
    "Buy when signal crosses over lag1, sell when signal crosses under lag1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cg(series, length, fperiod=None, stoch_time=None):\n",
    "    \"\"\"\n",
    "    CG - center of gravity\n",
    "    view the price as weight to compute the center of gravity of the filter\n",
    "    :param series: (np.array) price\n",
    "    :param length: (int) window length\n",
    "    :param period: (int) fisher transformation parameter\n",
    "    :param stoch_time: (int) fisher transformation parameter\n",
    "    :return: (np.array) cg\n",
    "    \"\"\"\n",
    "    # compute cg\n",
    "    num = np.zeros_like(series)\n",
    "    denom = np.ones_like(series)\n",
    "    for i in range(length - 1, series.shape[0]):\n",
    "        num[i] = np.sum((np.array(range(length)) + 1) * series[i - length + 1:i + 1][::-1])\n",
    "        denom[i] = np.sum(series[i - length + 1:i + 1])\n",
    "    cg = -num / denom + (1 + length) / 2\n",
    "    # apply fisher transformation\n",
    "    if fperiod:\n",
    "        cg = fisher(cg, fperiod, stoch_time)\n",
    "    return cg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### relative vigor index\n",
    "1) **method**\n",
    "    \n",
    "$\\text{rvi} = \\text{\"smoothed\"} \\ \\frac{\\text{c - o}}{\\text{h - l}}$\n",
    "    \n",
    "2) **parameter range**\n",
    "    \n",
    "* length $(0, +\\infty)$: window length\n",
    "\n",
    "* fperiod, stoch_time: same as fisher transformation parameters\n",
    "\n",
    "3) **trading strategy**\n",
    "    \n",
    "Buy when signal crosses over lag1, sell when signal crosses under lag1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rvi(o, h, l, c, length, fperiod=None, stoch_time=None):\n",
    "    \"\"\"\n",
    "    RVI - relative vigor index\n",
    "    :param o: (np.array) open\n",
    "    :param h: (np.array) high\n",
    "    :param l: (np.array) low\n",
    "    :param c: (np.array) close\n",
    "    :param length: length to sum the num & denom\n",
    "    :param period: (int) fisher transformation parameter\n",
    "    :param stoch_time: (int) fisher transformation parameter\n",
    "    :return: (np.array) rvi\n",
    "    \"\"\"\n",
    "    co = c - o\n",
    "    hl = h - l\n",
    "    num = sma4(co)\n",
    "    denom = sma4(hl)\n",
    "    rvi = np.zeros_like(o)\n",
    "    for i in range(2 + length, o.shape[0]):\n",
    "        rvi[i] = np.sum(num[i - length + 1:i + 1]) / np.sum(denom[i - length + 1:i + 1])\n",
    "    # apply fisher transformation\n",
    "    if fperiod:\n",
    "        rvi = fisher(rvi, fperiod, stoch_time)\n",
    "    return rvi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### relative strength index\n",
    "The famous RSI. Written here to show its similarity to the 3 cycle indicators above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rsi(series, length, fperiod=None, stoch_time=None):\n",
    "    \"\"\"\n",
    "    Relative Strength Index\n",
    "    :param series: (np.array) price\n",
    "    :param length: length to sum the num & denom\n",
    "    :param period: (int) fisher transformation parameter\n",
    "    :param stoch_time: (int) fisher transformation parameter\n",
    "    :return: (np.array) rsi\n",
    "    \"\"\"\n",
    "    rsi = ta.RSI(series, length)\n",
    "    # apply fisher transformation\n",
    "    if fperiod:\n",
    "        rsi = fisher(rsi, fperiod, stoch_time)\n",
    "    return rsi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Laguerre RSI\n",
    "1) **method**\n",
    "\n",
    "Not fully understood :(\n",
    "    \n",
    "2) **parameter range**\n",
    "\n",
    "* gamma $(0, 1)$: allpass filter parameter\n",
    "\n",
    "* period, stoch_time: same as fisher transformation parameters\n",
    "\n",
    "3) **trading strategy**\n",
    "    \n",
    "Same as RSI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laguerre_rsi(series, gamma, fperiod=None, stoch_time=None):\n",
    "    \"\"\"\n",
    "    Laguerre RSI\n",
    "    :param series: (np.array) price\n",
    "    :param gamma: (float) damping factor\n",
    "    :param period: (int) fisher transformation parameter\n",
    "    :param stoch_time: (int) fisher transformation parameter\n",
    "    :return: (np.array) rsi\n",
    "    \"\"\"\n",
    "    l0, l1, l2, l3 = laguerre(series, gamma)\n",
    "    rsi = np.zeros_like(series)\n",
    "    for i in range(series.shape[0]):\n",
    "        cu = 0\n",
    "        cd = 0\n",
    "        if l1[i] > l0[i]:\n",
    "            cu += l1[i] - l0[i]\n",
    "        else:\n",
    "            cd -= l1[i] - l0[i]\n",
    "        if l2[i] > l1[i]:\n",
    "            cu += l2[i] - l1[i]\n",
    "        else:\n",
    "            cd -= l2[i] - l1[i]\n",
    "        if l3[i] > l2[i]:\n",
    "            cu += l3[i] - l2[i]\n",
    "        else:\n",
    "            cd -= l3[i] - l2[i]\n",
    "        rsi[i] = cu / (cu + cd)\n",
    "    # apply fisher transformation\n",
    "    if fperiod:\n",
    "        rsi = fisher(rsi, fperiod, stoch_time)\n",
    "    return rsi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: The 3 indicators below requires large amounts of computation when the input max_period(max_lag) and min_period(min_lag) are large, as it needs to compute for every period between the max and the min. It can be optimized, though, if we let it memotize the situation it has computed. \n",
    "\n",
    "Within the 3 methods, this first one is the prefered one as it incurs no spectral dilation.\n",
    "\n",
    "### auto-correlation periodogram indicator\n",
    "\n",
    "1) **parameter range**\n",
    "\n",
    "* hp_period $(0, +\\infty)$\n",
    "\n",
    "* lp_period $(0, +\\infty)$\n",
    "\n",
    "* average_len $(0, +\\infty)$\n",
    "\n",
    "* max_lag, min_lag $0<\\text{min_lag}<\\text{max_lag}< +\\infty)$\n",
    "\n",
    "2) **trading strategy**\n",
    "\n",
    "Buy when signal crosses over lag1, sell when signal crosses under lag1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def corr_periodogram(series, hp_period, lp_period, average_len, max_lag, min_lag):\n",
    "    \"\"\"\n",
    "    auto-correlation periodogram indicator: a preferred method to compute the dominant cycle\n",
    "    :param hp_period: highpass period to remove the trend from the original price\n",
    "    :param lp_period: lowpass period to smooth the original price\n",
    "    :param average_len: # period to compute auto-correlation\n",
    "    :param max_lag: max lag of period to compute auto_correlation\n",
    "    :param min_lag: min lag of period to compute auto_correlation\n",
    "    :return: (np.array) dominant cycle\n",
    "    \"\"\"\n",
    "    num = np.zeros_like(series)\n",
    "    denom = np.zeros_like(series)\n",
    "    for lag in range(min_lag, max_lag):\n",
    "\n",
    "        rho = corr(series, hp_period, lp_period, average_len, lag)\n",
    "        cos_part = np.zeros_like(series)\n",
    "        sin_part = np.zeros_like(series)\n",
    "        for i in range(max_lag):\n",
    "            cos_part += np.roll(rho, i) * np.cos(2 * np.pi * i / max_lag)\n",
    "            sin_part += np.roll(rho, i) * np.sin(2 * np.pi * i / max_lag)\n",
    "        sqsum = cos_part ** 2 + sin_part ** 2\n",
    "\n",
    "        for i in range(1, sqsum.shape[0]):\n",
    "            sqsum[i] = 0.2 * sqsum[i] + 0.8 * sqsum[i - 1]\n",
    "\n",
    "        K = 0.991\n",
    "        peak = np.copy(sqsum)\n",
    "        for i in range(sqsum.shape[0]):\n",
    "            if i > 0:\n",
    "                peak[i] = peak[i - 1] * K\n",
    "            if abs(sqsum[i]) > peak[i]:\n",
    "                peak[i] = abs(sqsum[i])\n",
    "        sqsum = sqsum / peak\n",
    "        sqsum[np.isnan(sqsum)] = 0\n",
    "\n",
    "        num += (sqsum > 0.5) * sqsum * lag\n",
    "        denom += (sqsum > 0.5) * sqsum\n",
    "\n",
    "    dc = num / denom\n",
    "    dc[np.isnan(dc)] = 0\n",
    "    return dc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### center of gravity indicator based on discrete Fourier tansformation\n",
    "1) **parameter range**\n",
    "\n",
    "* hp_period $(0, +\\infty)$\n",
    "\n",
    "* lp_period $(0, +\\infty)$\n",
    "\n",
    "* max_period, min_period $0<\\text{min_period}<\\text{max_period}< +\\infty)$\n",
    "\n",
    "2) **trading strategy**\n",
    "\n",
    "Buy when signal crosses over lag1, sell when signal crosses under lag1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dft(series, hp_period, lp_period, dft_period):\n",
    "    \"\"\"\n",
    "    discrete Fourier Transformation\n",
    "    :param hp_period: highpass period to remove the trend from the original price\n",
    "    :param lp_period: lowpass period to smooth the original price\n",
    "    :param dft_period: period to compute Fourier transformation\n",
    "    :return: (np.array) normalized power\n",
    "    \"\"\"\n",
    "    HP = highpass2pole(series, hp_period)\n",
    "    filt = supersmoother2pole(HP, lp_period)\n",
    "\n",
    "    cos_part = np.zeros_like(series)\n",
    "    sin_part = np.zeros_like(series)\n",
    "    for i in range(dft_period):\n",
    "        cos_part += np.roll(filt, i) * np.cos(2 * np.pi * i / dft_period) / dft_period\n",
    "        sin_part += np.roll(filt, i) * np.sin(2 * np.pi * i / dft_period) / dft_period\n",
    "    pwr = cos_part ** 2 + sin_part ** 2\n",
    "\n",
    "    K = 0.991\n",
    "    peak = np.copy(pwr)\n",
    "    for i in range(series.shape[0]):\n",
    "        if i > 0:\n",
    "            peak[i] = peak[i - 1] * K\n",
    "        if abs(pwr[i]) > peak[i]:\n",
    "            peak[i] = abs(pwr[i])\n",
    "    pwr = pwr / peak\n",
    "    pwr[np.isnan(pwr)] = 0\n",
    "    return pwr\n",
    "\n",
    "\n",
    "def dft_cg(series, hp_period, lp_period, max_period, min_period):\n",
    "    \"\"\"\n",
    "    center of gravity indicator based on discrete Fourier tansformation: indicates dominant cycle\n",
    "    :param hp_period: highpass period to remove the trend from the original price\n",
    "    :param lp_period: lowpass period to smooth the original price\n",
    "    :param max_period: max period to compute Fourier transformation\n",
    "    :param min_period: min period to compute Fourier transformation\n",
    "    :return: (np.array) dominant cycle\n",
    "    \"\"\"\n",
    "    num = np.zeros_like(series)\n",
    "    denom = np.zeros_like(series)\n",
    "    for period in range(min_period, max_period):\n",
    "        pwr = dft(series, hp_period, lp_period, period)\n",
    "        num += (pwr>0.5)*pwr*period\n",
    "        denom += (pwr>0.5)*pwr\n",
    "    dc = num/denom\n",
    "    dc[np.isnan(dc)] = 0\n",
    "    return dc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### comb filter\n",
    "1) **parameter range**\n",
    "\n",
    "* hp_period $(0, +\\infty)$\n",
    "\n",
    "* lp_period $(0, +\\infty)$\n",
    "\n",
    "* max_period, min_period $0<\\text{min_period}<\\text{max_period}< +\\infty)$\n",
    "\n",
    "* bandwidth $(0, 2)$\n",
    "\n",
    "2) **trading strategy**\n",
    "\n",
    "Buy when signal crosses over lag1, sell when signal crosses under lag1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def comb(series, hp_period, lp_period, max_period, min_period, bandwidth):\n",
    "    \"\"\"\n",
    "    comb filter spectral estimate: compute the dominant cycle\n",
    "    :param hp_period: highpass period to remove the trend from the original price\n",
    "    :param lp_period: lowpass period to smooth the original price\n",
    "    :param max_period: max period to compute bandpass\n",
    "    :param min_period: min period to compute bandpass\n",
    "    :param bandwidth: bandwidth for bandpass filter\n",
    "    :return: (np.array) dominant cycle\n",
    "    \"\"\"\n",
    "    num = np.zeros_like(series)\n",
    "    denom = np.zeros_like(series)\n",
    "    HP = highpass2pole(series, hp_period)\n",
    "    filt = supersmoother2pole(HP, lp_period)\n",
    "    for period in range(min_period, max_period):\n",
    "\n",
    "        bp, _, _ = bandpass(filt, period, bandwidth)\n",
    "        pwr = np.zeros_like(bp)\n",
    "        for i in range(period):\n",
    "            pwr += np.roll(bp, i) ** 2 / period ** 2\n",
    "\n",
    "        K = 0.991\n",
    "        peak = np.copy(pwr)\n",
    "        for i in range(pwr.shape[0]):\n",
    "            if i > 0:\n",
    "                peak[i] = peak[i - 1] * K\n",
    "            if abs(pwr[i]) > peak[i]:\n",
    "                peak[i] = abs(pwr[i])\n",
    "        pwr = pwr / peak\n",
    "        pwr[np.isnan(pwr)] = 0\n",
    "\n",
    "        num += (pwr > 0.5) * pwr * period\n",
    "        denom += (pwr > 0.5) * pwr\n",
    "\n",
    "    dc = num / denom\n",
    "    dc[np.isnan(dc)] = 0\n",
    "    return dc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VI. Predictive Method\n",
    "These indicators has the ability to actually predict the price in the future.\n",
    "### Hilbert Indicator\n",
    "1) **method**\n",
    "\n",
    "Use the Hilbert Transformation to create the real line and imaginary line.\n",
    "    \n",
    "2) **parameter range**\n",
    "\n",
    "* hp_period $(0, +\\infty)$\n",
    "\n",
    "* lp_period $(0, +\\infty)$\n",
    "\n",
    "* smooth_period $(0, +\\infty)$\n",
    "\n",
    "3) **trading strategy**\n",
    "\n",
    "Buy when the imaginary line crosses above the real line, short otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hilbert_indicator(series, hp_period, lp_period, smooth_period):\n",
    "    \"\"\"\n",
    "    hilbert transformation indicator: the real line moves as the original price, while the imaginary line as predictor\n",
    "    :param series: (np.array) price\n",
    "    :param hp_period: highpass period to remove the trend from the original price\n",
    "    :param lp_period: lowpass period to smooth the original price\n",
    "    :param smooth_period: lowpass period to smooth the imaginary line\n",
    "    :return: (np.array) the real and imag line\n",
    "    \"\"\"\n",
    "    HP = highpass2pole(series, hp_period)\n",
    "    filt = supersmoother2pole(HP, lp_period)\n",
    "\n",
    "    K = 0.991\n",
    "    peak = np.copy(filt)\n",
    "    for i in range(series.shape[0]):\n",
    "        if i > 0:\n",
    "            peak[i] = peak[i - 1] * K\n",
    "        if abs(filt[i]) > peak[i]:\n",
    "            peak[i] = abs(filt[i])\n",
    "    real = filt / peak\n",
    "    real[np.isnan(real)] = 0\n",
    "\n",
    "    quad = real - np.roll(real, 1)\n",
    "    quad[0] = 0\n",
    "    K = 0.991\n",
    "    peak = np.copy(quad)\n",
    "    for i in range(series.shape[0]):\n",
    "        if i > 0:\n",
    "            peak[i] = peak[i - 1] * K\n",
    "        if abs(quad[i]) > peak[i]:\n",
    "            peak[i] = abs(quad[i])\n",
    "    quad = quad / peak\n",
    "    quad[np.isnan(quad)] = 0\n",
    "\n",
    "    imag = supersmoother2pole(quad, smooth_period)\n",
    "\n",
    "    return real, imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sinewave Indicator\n",
    "1) **method**\n",
    "\n",
    "Predict the price as a sinewave whose period is changing and is computed using Hilbert Transformation\n",
    "    \n",
    "2) **parameter range**\n",
    "\n",
    "* cutoff_period $(0, +\\infty)$: cutoff period for Hilbert Transformation\n",
    "\n",
    "* lead $(0, 360)$: lead angle for the trigger\n",
    "\n",
    "3) **trading strategy**\n",
    "\n",
    "Trigger is the predicted sinewave plus an angle.\n",
    "\n",
    "Buy when trigger crosses over sinewave, short otherwise.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sinewave(series, cutoff_period, lead=0.25 * np.pi):\n",
    "    \"\"\"\n",
    "    sinewave indicator\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff_period: (float) the cutoff period used to compute the period using Hilbert Transformation\n",
    "    :param lead: (float) lead angle, in radians\n",
    "    :return: (np.array) sinewave and leadsine\n",
    "    \"\"\"\n",
    "    # compute period\n",
    "    period, cycle = compute_period(series, cutoff_period)\n",
    "    dcperiod = period.astype(np.int)\n",
    "    # compute dominant cycle phase\n",
    "    real = np.zeros_like(series)\n",
    "    imag = np.zeros_like(series)\n",
    "    dcphase = np.zeros_like(series)\n",
    "    for i in range(series.shape[0]):\n",
    "        for j in range(dcperiod[i]):\n",
    "            real[i] += np.sin(2 * np.pi * j / dcperiod[i]) * cycle[i]\n",
    "            imag[i] += np.cos(2 * np.pi * j / dcperiod[i]) * cycle[i]\n",
    "        if abs(imag[i] > 0.001):\n",
    "            dcphase[i] = np.arctan(real[i] / imag[i])\n",
    "        else:\n",
    "            dcphase[i] = 0.5 * np.pi * np.sign(real[i])\n",
    "        dcphase[i] += 0.5 * np.pi\n",
    "        if imag[i] < 0:\n",
    "            dcphase[i] += np.pi\n",
    "        if dcphase[i] > 1.75 * np.pi:\n",
    "            dcphase[i] -= 2 * np.pi\n",
    "    # compute sinewave\n",
    "    sinewave = np.sin(dcphase)\n",
    "    leadsine = np.sin(dcphase + lead)\n",
    "    return sinewave, leadsine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Even Better Sinewave Indicator\n",
    "1) **method**\n",
    "\n",
    "* Pass the data in a roofing filter\n",
    "\n",
    "* smoothed $\\frac{\\text(wave)}{\\text{power}}$\n",
    "    \n",
    "2) **parameter range**\n",
    "\n",
    "* hp_period $(0, +\\infty)$\n",
    "\n",
    "* lp_period $(0, +\\infty)$\n",
    "\n",
    "3) **trading strategy**\n",
    "\n",
    "Buy when the normalized wave exceeds some upper bound, short when below some lower bound.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def better_sinewave(series, hp_period, lp_period):\n",
    "    \"\"\"\n",
    "    the even better sinewave indicator: profits better when the market is in a trend mode\n",
    "    :param hp_period: highpass period to remove the trend from the original price\n",
    "    :param lp_period: lowpass period to smooth the original price\n",
    "    :return: (np.array) sinewave\n",
    "    \"\"\"\n",
    "    HP = highpass(series, hp_period)\n",
    "    filt = supersmoother2pole(HP, lp_period)\n",
    "    wave = (filt + np.roll(filt,1) + np.roll(filt,2))/3\n",
    "    wave[0] = filt[0]\n",
    "    wave[1] = (filt[0]+filt[1])/2\n",
    "    pwr = (filt**2 + np.roll(filt,1)**2 + np.roll(filt,2)**2)/3\n",
    "    pwr[0] = filt[0]**2\n",
    "    pwr[1] = (filt[0]**2+filt[1]**2)/2\n",
    "    wave = wave/np.sqrt(pwr)\n",
    "    wave[np.isnan(wave)] = 0\n",
    "    return wave"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VII. Adaptive Methods\n",
    "The word adaptive means that in these indicators, period is viewed as an endogenous variable rather than a constant input parameter. Theoretically, if the indicator with an constant period works well, and if the period is approximated well, the adaptive method should work even better as it allows the period to change.\n",
    "\n",
    "Unfortunately in our case, as far as I know, neither of the \"if\" is satisfied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ad_cci(series, cutoff_period, cutoff_signal, fperiod=None, stoch_time=None):\n",
    "    \"\"\"\n",
    "    adaptive cyber cycle\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff_period: (float) the cutoff period used to compute the period using Hilbert Transformation\n",
    "    :param cutoff_signal: (float) the cutoff period used to smooth the signal\n",
    "    :param period: (int) fisher transformation parameter\n",
    "    :param stoch_time: (int) fisher transformation parameter\n",
    "    :return: (np.array) cycle\n",
    "    \"\"\"\n",
    "    # compute period\n",
    "    period, _ = compute_period(series, cutoff_period)\n",
    "    # compute the cycle\n",
    "    smooth = sma4(series)\n",
    "    cycle = ad_highpass2pole(smooth, period)\n",
    "    for t in range(2, 7):\n",
    "        cycle[t] = (series[t] - 2 * series[t - 1] + series[t - 2]) / 4\n",
    "    signal = ema(cycle, cutoff_signal)\n",
    "    # apply fisher transformation\n",
    "    if fperiod:\n",
    "        signal = fisher(signal, fperiod, stoch_time)\n",
    "    return signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ad_cg(series, cutoff_period, fperiod=None, stoch_time=None):\n",
    "    \"\"\"\n",
    "\n",
    "    :param series: (np.array) price\n",
    "    :param cutoff_period: (float) the cutoff period used to compute the period using Hilbert Transformation\n",
    "    :param period: (int) fisher transformation parameter\n",
    "    :param stoch_time: (int) fisher transformation parameter\n",
    "    :return: (np.array) cg\n",
    "    \"\"\"\n",
    "    # compute period\n",
    "    period, _ = compute_period(series, cutoff_period)\n",
    "    length = (period / 2).astype(np.int)\n",
    "    # compute cg\n",
    "    num = np.zeros_like(series)\n",
    "    denom = np.ones_like(series)\n",
    "    for i in range(length[1] - 1, series.shape[0]):\n",
    "        num[i] = np.sum((np.array(range(length[i])) + 1) * series[i - length[i] + 1:i + 1][::-1])\n",
    "        denom[i] = np.sum(series[i - length[i] + 1:i + 1])\n",
    "    cg = -num / denom + (1 + length) / 2\n",
    "    # apply fisher transformation\n",
    "    if fperiod:\n",
    "        cg = fisher(cg, fperiod, stoch_time)\n",
    "    return cg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VIII. Turning Point Indicator\n",
    "### Auto-correlation Indicator\n",
    "1) **method**\n",
    "\n",
    "* If the correlation between ①[ now - average_len , now ] and ②[ now - average_len - lag , now - lag ] is small, it indicates a turning point\n",
    "    \n",
    "2) **parameter range**\n",
    "\n",
    "* hp_period $(0, +\\infty)$\n",
    "\n",
    "* lp_period $(0, +\\infty)$\n",
    "\n",
    "* average_len $(0, +\\infty)$\n",
    "\n",
    "* lag $(0, +\\infty)$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def corr(series, hp_period, lp_period, average_len, lag):\n",
    "    \"\"\"\n",
    "    auto-correlation indicator: indicates reversal when it's near -1\n",
    "    :param hp_period: highpass period to remove the trend from the original price\n",
    "    :param lp_period: lowpass period to smooth the original price\n",
    "    :param average_len: # period to compute auto-correlation\n",
    "    :param lag: lag of period to compute auto_correlation\n",
    "    :return: (np.array) correlation\n",
    "    \"\"\"\n",
    "    HP = highpass2pole(series, hp_period)\n",
    "    filt = supersmoother2pole(HP, lp_period)\n",
    "    corr = np.zeros_like(series)\n",
    "    for i in range(average_len + lag, series.shape[0] + 1):\n",
    "        s1 = filt[i - average_len:i]\n",
    "        s2 = filt[i - average_len - lag:i - lag]\n",
    "        corr[i - 1] = np.corrcoef(s1, s2)[0, 1]\n",
    "    return corr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Auto-correlation Reversal Indicator\n",
    "1) **method**\n",
    "\n",
    "* Based on the correlation indicator, it takes the differece of 2 correlations. If the sum of change amounts to a certain threshold, it would signal a turning point.\n",
    "    \n",
    "2) **parameter range**\n",
    "\n",
    "* hp_period $(0, +\\infty)$\n",
    "\n",
    "* lp_period $(0, +\\infty)$\n",
    "\n",
    "* average_len $(0, +\\infty)$\n",
    "\n",
    "* lag $(0, +\\infty)$\n",
    "\n",
    "* thresh $(0, 2*lag)$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def corr_reversal(series, hp_period, lp_period, average_len, lag, thresh):\n",
    "    \"\"\"\n",
    "    auto-correlation reversal indicator indicates the reversals of the price\n",
    "    :param hp_period: highpass period to remove the trend from the original price\n",
    "    :param lp_period: lowpass period to smooth the original price\n",
    "    :param average_len: # period to compute auto-correlation\n",
    "    :param lag: lag of period to compute auto_correlation\n",
    "    :param: thresh: if the num of reversal-indicator delta happens more than thresh times in the lag period,\n",
    "                    it indicates a overall reversal\n",
    "    :return: (np.array) reversal indicator based on the threshold as well as the original sum of delta\n",
    "    \"\"\"\n",
    "    HP = highpass2pole(series, hp_period)\n",
    "    filt = supersmoother2pole(HP, lp_period)\n",
    "    corr = np.zeros_like(series)\n",
    "    for i in range(average_len + lag, series.shape[0] + 1):\n",
    "        s1 = filt[i - average_len:i]\n",
    "        s2 = filt[i - average_len - lag:i - lag]\n",
    "        corr[i - 1] = np.corrcoef(s1, s2)[0, 1]\n",
    "    corr_1 = corr > 0\n",
    "    corr_2 = np.roll(corr_1, 1)\n",
    "    delta = np.abs(corr_1 - corr_2) / 2\n",
    "    delta[0] = 0\n",
    "    sumdelta = np.zeros_like(delta)\n",
    "    for i in range(lag):\n",
    "        sumdelta += np.roll(delta, i)\n",
    "    reversal = sumdelta >= thresh\n",
    "    return reversal, sumdelta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concolution Indicator\n",
    "1) **method**\n",
    "\n",
    "* If the convolution of [ now - lookback_period , now ] is larger, it indicates a turning point.\n",
    "    \n",
    "2) **parameter range**\n",
    "\n",
    "* hp_period $(0, +\\infty)$\n",
    "\n",
    "* lp_period $(0, +\\infty)$\n",
    "\n",
    "* lookback_period $(0, +\\infty)$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convolution(series, hp_period, lp_period, lookback_period):\n",
    "    \"\"\"\n",
    "    convolution indicator: use convolution within a lookback period to determine whether a turning point has occurred\n",
    "    :param series: (np.array) price\n",
    "    :param hp_period: highpass period to remove the trend from the original price\n",
    "    :param lp_period: lowpass period to smooth the original price\n",
    "    :param lookback_period: lookback period to compute convolution\n",
    "    :return: (np.array) normalized convolution [0,1] and original convolution [-1,1]\n",
    "    \"\"\"\n",
    "    HP = highpass2pole(series, hp_period)\n",
    "    filt = supersmoother2pole(HP, lp_period)\n",
    "\n",
    "    corr = np.zeros_like(series)\n",
    "    for i in range(lookback_period, series.shape[0] + 1):\n",
    "        lookback_ = filt[i - lookback_period:i]\n",
    "        corr[i - 1] = np.corrcoef(lookback_, np.flip(lookback_))[0, 1]\n",
    "    conv = (1 + (np.exp(3 * corr) - 1) / (np.exp(3 * corr) + 1)) / 2\n",
    "\n",
    "    return conv, corr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IX. Lead Indicator\n",
    "1) **method**\n",
    "\n",
    "* This indicator generates \"lead\" in the indicators to somehow achieve the effect similiar to prediction.\n",
    "    \n",
    "2) **parameter range**\n",
    "\n",
    "* alpha1 $(0, 1)$\n",
    "\n",
    "* alpha2 $(\\text{alpha1}, 1)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lead(series, alpha1, alpha2):\n",
    "    \"\"\"\n",
    "    lead indicator\n",
    "    :param series: (np.array) price\n",
    "    :param alpha1: (float) alpha to generate lead\n",
    "    :param alpha2: (float) alpha to smooth while offsetting some lead\n",
    "    :return: (np.array) netlead\n",
    "    \"\"\"\n",
    "    assert alpha1 < alpha2\n",
    "    lead = np.zeros_like(series)\n",
    "    netlead = np.zeros_like(series)\n",
    "    for i in range(1, series.shape[0]):\n",
    "        lead[i] = 2 * series[i] + (alpha1 - 2) * series[i - 1] \\\n",
    "                  + (1 - alpha1) * lead[i - 1]\n",
    "        netlead[i] = alpha2 * lead[i] + (1 - alpha2) * netlead[i - 1]\n",
    "    return netlead"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}