williamyang98/calculate_horner_polynomial_gradient_descent.cpp

## calculate_horner_polynomial_gradient_descent.cpp
// Compiling with clang or gcc
// clang main.cpp -o main -march=native -O3 -ffast-math -Wextra -Werror -Wunused-parameter -lm
// Use "-march=native -ffast-math -O3" for faster gradient descent
// Use "-lm" if linking to glibc math libraries on Linux
// Remove "-W*" warning flags if you don't need checks

#define _USE_MATH_DEFINES
#include <stdio.h>
#include <cmath>
#include <vector>

#define USE_SIGNAL_HANDLER 1

#if USE_SIGNAL_HANDLER
static bool is_running = true;
#if _WIN32
#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>
BOOL WINAPI sighandler(DWORD signum) {
    if (signum == CTRL_C_EVENT) {
        fprintf(stderr, "Signal caught, exiting!\n");
        is_running = false;
        return TRUE;
    }
    return FALSE;
}
#else
#include <errno.h>
#include <signal.h>
static void sighandler(int signum) {
    fprintf(stderr, "Signal caught, exiting! (%d)\n", signum);
    is_running = false;
}
#endif
#endif

// Configuration
using grad_t = double;
using coefficient_t = double;
constexpr size_t PRINT_ITER = 10'000'000;
constexpr size_t TOTAL_ITER_ERROR_PLATEAU_THRESHOLD = 10'000;

// Learning rate update rule when minimum error reaches a plateau
// - If we update than rescale the learning rate
// - Otherwise we exit early
constexpr bool IS_UPDATE_LEARNING_RATE = true;
constexpr grad_t LEARNING_RATE_RESCALER = 1.1;

// We are solving for a[n] in g(x) = sum a[n]*x^(2n)
// Where f(x) = h(x)*g(x), where:
//   - f(x) = target function
//   - h(x) = modifier function to reduce complexity of function g(x) needs to solve
//   - g(x) = polynomial that can be calculated using Horner's method
//            https://en.wikipedia.org/wiki/Horner%27s_method

// Gradient descent hyperparameters
// - We are approximating f(x) in the range: x = [X_SAMPLE_START, X_SAMPLE_END] with TOTAL_SAMPLES
// - g(x) = sum a[n]*x^(2n) for n = [0, TOTAL_COEFFICIENTS-1]
// - learning rate: INITIAL_LEARNING_RATE
//   - Decrease learning rate if unstable
// - rescaling gradients for de/da[n] by: x^(n*GRAD_RESCALE_MAGNITUDE + GRAD_RESCALE_BIAS)
//   - NOTE: This drastically improves training speed, you should tweak it
//   - Decrease GRAD_RESCALE_MAGNITUDE if training is unstable
//   - NOTE: You should tweak this value before tweaking learning rate

// Sample functions to approximate
#if 1
// y = sin(2*pi*x)
template <typename T>
inline static T get_y_target(T x) {
    return std::sin(T(M_PI)*2.0*x);
}
template <typename T>
inline static T get_h(T x) {
    // constraint so that roots match sin(2*pi*x)
    constexpr T B0 = T(0.5*0.5);
    const T z = x*x;
    return x*(z-B0);
}
constexpr size_t TOTAL_SAMPLES = 256;
constexpr grad_t X_SAMPLE_START = grad_t(0);
constexpr grad_t X_SAMPLE_END = grad_t(0.5);
constexpr size_t TOTAL_COEFFICIENTS = 6;
constexpr grad_t INITIAL_LEARNING_RATE = grad_t(1e0);
constexpr grad_t GRAD_RESCALE_MAGNITUDE = 4;
constexpr grad_t GRAD_RESCALE_BIAS = 1;
#elif 0
// y = cos(2*pi*x)
template <typename T>
inline static T get_y_target(T x) {
    return std::cos(T(M_PI)*2.0*x);
}
template <typename T>
inline static T get_h(T x) {
    // constraint so that roots match cos(2*pi*x)
    constexpr T B0 = T(0.25*0.25);
    constexpr T B1 = T(0.75*0.75);
    const T z = x*x;
    return (z-B0)*(z-B1);
}
constexpr size_t TOTAL_SAMPLES = 256;
constexpr grad_t X_SAMPLE_START = grad_t(0);
constexpr grad_t X_SAMPLE_END = grad_t(0.5 + 1e-2);
constexpr size_t TOTAL_COEFFICIENTS = 6;
constexpr grad_t INITIAL_LEARNING_RATE = grad_t(1e0);
constexpr grad_t GRAD_RESCALE_MAGNITUDE = 4;
constexpr grad_t GRAD_RESCALE_BIAS = 1;
#else
// y = x^2 * exp(pi*x^2) * sin(2pix)
template <typename T>
inline static T get_y_target(T x) {
    const T z = x*x;
    return z*std::exp(T(M_PI)*z)*std::sin(2*T(M_PI)*x);
}
template <typename T>
inline static T get_h(T x) {
    constexpr T B0 = T(0.5*0.5);
    const T z = x*x;
    return z*x*(z-B0);
}
constexpr size_t TOTAL_SAMPLES = 256;
constexpr grad_t X_SAMPLE_START = grad_t(0);
constexpr grad_t X_SAMPLE_END = grad_t(0.5 + 1e-2);
constexpr size_t TOTAL_COEFFICIENTS = 8;
constexpr grad_t INITIAL_LEARNING_RATE = grad_t(1e0);
constexpr grad_t GRAD_RESCALE_MAGNITUDE = 3.6; // needed to be decreased for stable gradient descent
constexpr grad_t GRAD_RESCALE_BIAS = 1;
#endif

inline static coefficient_t get_horner_polynomial(coefficient_t x, coefficient_t* A) {
    // g(x) = sum a[n]*x^(2n)
    // Use Horner's method to calculate this efficiently
    // https://en.wikipedia.org/wiki/Horner%27s_method
    const coefficient_t z = x*x;
    coefficient_t g = A[TOTAL_COEFFICIENTS-1];
    for (size_t i = 1; i < TOTAL_COEFFICIENTS; i++) {
        size_t j = TOTAL_COEFFICIENTS-i-1;
        g = g*z + A[j];
    }
    return g;
}

int main(int /*argc*/, char** /*argv*/) {
#if USE_SIGNAL_HANDLER
#if _WIN32
    SetConsoleCtrlHandler(sighandler, TRUE);
#else
    struct sigaction sigact;
    sigact.sa_handler = sighandler;
    sigemptyset(&sigact.sa_mask);
    sigact.sa_flags = 0;
    sigaction(SIGINT, &sigact, nullptr);
    sigaction(SIGTERM, &sigact, nullptr);
    sigaction(SIGQUIT, &sigact, nullptr);
    sigaction(SIGPIPE, &sigact, nullptr);
#endif
#endif
    coefficient_t poly[TOTAL_COEFFICIENTS] = {coefficient_t(0)};

    static_assert(X_SAMPLE_END > X_SAMPLE_START, "Range of evaluation must be from x_min to x_max");
    constexpr grad_t EVAL_STEP = (X_SAMPLE_END-X_SAMPLE_START)/grad_t(TOTAL_SAMPLES);
    auto X_in = std::vector<grad_t>(TOTAL_SAMPLES);
    auto Y_expected = std::vector<grad_t>(TOTAL_SAMPLES);
    auto H_in = std::vector<grad_t>(TOTAL_SAMPLES);
    for (size_t i = 0; i < TOTAL_SAMPLES; i++) {
        const grad_t x = X_SAMPLE_START + grad_t(i)*EVAL_STEP;
        const grad_t y = get_y_target(x);
        const grad_t h = get_h(x);
        X_in[i] = x;
        Y_expected[i] = y;
        H_in[i] = h;
    }

    // normalised gradients for each term
    // de/da[n] = 2*(f-y)*h*x^2n
    //          = 2*e(x)*h*x^2n
    // Assume e(x) converges to 0, then e_max = e^2n
    // de/da[n] = 2*h*x^4n
    // In reality the x^4n factor is approximated as x^(an+b)
    // where a,b are hyperparameters
    grad_t gradient_scale[TOTAL_COEFFICIENTS] = {0.0};
    for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
        grad_t scale = 0.0;
        for (size_t j = 0; j < TOTAL_SAMPLES; j++) {
            const grad_t x = grad_t(X_in[j]);
            const grad_t h = grad_t(H_in[j]);
            const grad_t n = grad_t(i)*GRAD_RESCALE_MAGNITUDE + GRAD_RESCALE_BIAS;
            const grad_t x_n = std::pow(x, n);
            scale += (h*x_n);
        }
        scale = std::abs(scale);
        scale /= grad_t(TOTAL_SAMPLES);
        gradient_scale[i] = grad_t(1) / scale;
    }
    printf("grad_rescale = [");
    for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
        printf("%.2e,", gradient_scale[i]);
    }
    printf("]\n");
    printf("is_update_learning_rate: %u\n", IS_UPDATE_LEARNING_RATE);

    constexpr grad_t NORM_SAMPLES = 1.0f / grad_t(TOTAL_SAMPLES);
    grad_t learning_rate = INITIAL_LEARNING_RATE;
    coefficient_t best_poly[TOTAL_COEFFICIENTS] = {coefficient_t(0)};
    grad_t error_minimum = grad_t(1e6);
    size_t error_minimum_iter = 0;
    size_t total_iter_error_plateau = 0;
    for (size_t iter = 0; ; iter++) {
        grad_t total_error = grad_t(0);
        grad_t gradients[TOTAL_COEFFICIENTS] = {grad_t(0)};
        for (size_t i = 0; i < TOTAL_SAMPLES; i++) {
            const coefficient_t x = X_in[i];
            const coefficient_t y_given = coefficient_t(H_in[i])*get_horner_polynomial(coefficient_t(x), poly);
            const grad_t y_expected = Y_expected[i];
            const grad_t error = grad_t(y_given) - y_expected;
            // gradient descent
            // g(x) = sum a[n]*x^(2n)
            // f(x) = g(x)*h(x)
            // e(x) = [f(x) - y]^2
            // de/df = 2*(f-y)
            // df/dg = h
            // de/dg = de/df * df/dg, chain rule
            // de/dg = 2*(f-y)*h
            // de/da[n] = de/dg * dg/da[n]
            // dg/da[n] = x^(2n)
            // de/da[n] = 2*(f-y)*h*x^2n
            const grad_t z = x*x;
            const grad_t h = H_in[i];
            grad_t gradient = error*h*grad_t(2);
            gradients[0] += gradient;
            for (size_t j = 1; j < TOTAL_COEFFICIENTS; j++) {
                gradient *= z;
                gradients[j] += gradient;
            }
            total_error += std::abs(error);
        }

        // normalised error and gradient
        total_error *= NORM_SAMPLES;
        for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
            const grad_t scale = NORM_SAMPLES * gradient_scale[i];
            gradients[i] *= scale;
        }

        // save lowest error polynomial
        if (total_error < error_minimum && !std::isnan(total_error)) {
            error_minimum = total_error;
            error_minimum_iter = iter;
            total_iter_error_plateau = 0;
            for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
                best_poly[i] = poly[i];
            }
        } else {
            total_iter_error_plateau++;
        }

        if (iter % PRINT_ITER == 0) {
            printf("[%zu] error=%.2e, grad=[", iter, total_error);
            for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
                printf("%.2e,", gradients[i]);
            }
            printf("]\n");
        }

        // apply gradients
        bool has_nan = false;
        for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
            const grad_t delta = gradients[i] * learning_rate;
            const grad_t coeff = grad_t(poly[i]) - delta;
            poly[i] = coefficient_t(coeff);
            if (std::abs(coeff) > 1e5f) {
                printf("[%zu] [error] Detected exploding coefficient exiting\n", iter);
                has_nan = true;
                break;
            }
            if (std::isnan(coeff) || std::isinf(coeff)) {
                printf("[%zu] [error] Detected NAN in coefficient exiting\n", iter);
                has_nan = true;
                break;
            }
        }
        if (has_nan) {
            printf("[%zu] [error] Early exit due to bad values, printing them now\n", iter);
            printf("  learning_rate: %.2e\n", learning_rate);
            printf("  grad: [");
            for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
                printf("%.2e,", gradients[i]);
            }
            printf("]\n");
            printf("  poly: [");
            for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
                printf("%.2e,", poly[i]);
            }
            printf("]\n");
            break;
        }
        if (total_iter_error_plateau >= TOTAL_ITER_ERROR_PLATEAU_THRESHOLD) {
            if (IS_UPDATE_LEARNING_RATE) {
                total_iter_error_plateau = 0;
                learning_rate *= LEARNING_RATE_RESCALER;
            } else {
                printf("[%zu] [info] Exiting since error has plateaued after %zu iters\n",
                    iter, TOTAL_ITER_ERROR_PLATEAU_THRESHOLD);
                break;
            }
        }
        if (!is_running) break;
    }
    printf("\n[BEST RESULTS]\n");
    printf("step: %zu\n", error_minimum_iter);
    printf("mean_absolute_error: %.2e\n", error_minimum);
    printf("poly[%zu] = {", TOTAL_COEFFICIENTS);
    for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
        constexpr size_t total_dp = (sizeof(coefficient_t) == 4) ? 10 : 16;
        printf("%.*f", int(total_dp), best_poly[i]);
        if (i != TOTAL_COEFFICIENTS-1) {
            printf(",");
        }
    }
    printf("}\n");
    return 0;
}

## chebyshev_direct_computation.ipynb.ipynb
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "17ecb32e-0b96-43e9-97d3-d6050e076e5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b02ee861-1500-4b84-b7c6-0b41fcec95cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_Tn(n, cache):\n",
    "    if n == 0:\n",
    "        return np.array([1])\n",
    "    if n == 1:\n",
    "        return np.array([0,1])\n",
    "    if n in cache:\n",
    "        return cache[n]\n",
    "    # T_(n+1)(X) = 2*X*T_n(X) - T_(n-1)(X)\n",
    "    Tn_0 = calculate_Tn(n-1, cache)\n",
    "    Tn_1 = calculate_Tn(n-2, cache)\n",
    "\n",
    "    Tn = np.zeros((max(len(Tn_0)+1, len(Tn_1)),))\n",
    "    for i in range(len(Tn_0)):\n",
    "        Tn[i+1] += Tn_0[i]*2\n",
    "    for i in range(len(Tn_1)):\n",
    "        Tn[i] -= Tn_1[i]\n",
    "    cache[n] = Tn\n",
    "    return Tn\n",
    "\n",
    "def plot_Tn(Tn_coeffs, x):\n",
    "    y = np.zeros(x.shape)\n",
    "    xn = np.ones(x.shape)\n",
    "    for Tn_coeff in Tn_coeffs:\n",
    "        if Tn_coeff != 0:\n",
    "            y += Tn_coeff*xn\n",
    "        xn *= x\n",
    "    return y\n",
    "\n",
    "def get_xn(x, n, cache):\n",
    "    if n == 1:\n",
    "        return x\n",
    "    y = get_xn(x, n-1, cache)*x\n",
    "    cache[n] = y\n",
    "    return y\n",
    "\n",
    "def calc_integral_n(n, x, xn_cache={}, In_cache={}):\n",
    "    # In(x) = int x^n / sqrt(1-x^2) dx \n",
    "    # In(x) = 1/n * [ -x^(n-1) * sqrt(1-x^2) + (n-1) * I_(n-2)(x) ]\n",
    "    if n == 0:\n",
    "        return np.arcsin(x)\n",
    "    x_2 = get_xn(x, 2, xn_cache)\n",
    "    if n == 1:\n",
    "        return -np.sqrt(1-x_2)\n",
    "    if n in In_cache:\n",
    "        return In_cache[n]\n",
    "    x_n1 = get_xn(x, n-1, xn_cache)\n",
    "    I_n2 = calc_integral_n(n-2, x, xn_cache=xn_cache, In_cache=In_cache)\n",
    "    I_n = 1/n * (-x_n1*np.sqrt(1-x_2) + (n-1)*I_n2)\n",
    "    In_cache[n] = I_n\n",
    "    return I_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "75d0ece0-68f2-4cf3-b84c-aa7b523b2ad9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f1_calculate_chebyshev_polynomial():\n",
    "    #f_target = lambda x: np.cos(np.pi*x)\n",
    "    #f_target = lambda x: np.sin(2*np.pi*x)\n",
    "    #f_target = lambda x: np.exp(np.pi*x) * np.cos(8*np.pi*x)\n",
    "    #f_target = lambda x: np.tan(x)\n",
    "    def f_target(x):\n",
    "        # lambda x: np.sin(np.pi*x) / [x*(x-1)*(x+1)]\n",
    "        root = 1\n",
    "        A0 = np.pi\n",
    "        A1 = -A0/(root**2)\n",
    "        B0 = np.sin(A0*x)\n",
    "        B1 = np.copy(x)\n",
    "        B3 = x-root\n",
    "        B4 = x+root\n",
    "        epsilon = 1e-6\n",
    "        m0 = np.abs(B1) < epsilon\n",
    "        m1 = np.abs(B3) < epsilon\n",
    "        m2 = np.abs(B4) < epsilon\n",
    "        B0[m0 | m1 | m2] = A0\n",
    "        B1[m0] = 1\n",
    "        B3[m1] = -1\n",
    "        B4[m2] = -1\n",
    "        \n",
    "        y = B0/(B1*B3*B4) / A1\n",
    "        return y\n",
    "\n",
    "    IS_USE_POLY_APPROXIMATION = True\n",
    "    x = np.linspace(-1,1,1024)\n",
    "    y_target = f_target(x)\n",
    "    N = 9\n",
    "    \n",
    "    # quadratic fit on three points\n",
    "    # https://math.stackexchange.com/questions/680646/get-polynomial-function-from-3-points\n",
    "    # y = f(x) = ax^2 + bx + c\n",
    "    x1 = x[:-1]\n",
    "    x3 = x[1:]\n",
    "    x2 = (x1+x3)/2\n",
    "    y1 = f_target(x1)\n",
    "    y2 = f_target(x2)\n",
    "    y3 = f_target(x3)\n",
    "    Pa = (x1*(y3-y2) + x2*(y1-y3) + x3*(y2-y1))/((x1-x2)*(x1-x3)*(x2-x3))\n",
    "    Pb = (y2-y1)/(x2-x1) - Pa*(x1+x2)\n",
    "    Pc = y1-Pa*(x1*x1) - Pb*x1\n",
    "    \n",
    "    N_poly_samples = 4\n",
    "    x_poly = np.zeros((N_poly_samples*len(x1),))\n",
    "    y_poly = np.zeros((N_poly_samples*len(x1),))\n",
    "    for i in range(len(x1)):\n",
    "        xb = x3[i]\n",
    "        xa = x1[i]\n",
    "        j = slice(i*N_poly_samples, (i+1)*N_poly_samples)\n",
    "        x_ = np.linspace(xa, xb, N_poly_samples)\n",
    "        x_poly[j] = x_\n",
    "        y_poly[j] = Pa[i]*x_*x_ + Pb[i]*x_ + Pc[i]\n",
    "    \n",
    "    y_target_poly = f_target(x_poly)\n",
    "    y_poly_error = y_target_poly - y_poly\n",
    "    \n",
    "    An_cache = {}\n",
    "    Tn_cache = {}\n",
    "    xn_cache = {}\n",
    "    In_cache = {}\n",
    "    \n",
    "    Tn = calculate_Tn(N-1, Tn_cache)\n",
    "    for n in range(len(Tn)+2):\n",
    "        _ = calc_integral_n(n, x, xn_cache=xn_cache, In_cache=In_cache)\n",
    "    \n",
    "    for n in range(0, N):\n",
    "        Tn = np.array(calculate_Tn(n, Tn_cache))\n",
    "        M = len(Tn)+2\n",
    "        # Gn = Tn*f(x) as a set of polynomial sums\n",
    "        Gn = np.zeros((len(x1), M)) # (n-1) x m\n",
    "        if IS_USE_POLY_APPROXIMATION:\n",
    "            for (j, Pj) in enumerate((Pc,Pb,Pa)):\n",
    "                for (k, Tk) in enumerate(Tn):\n",
    "                    Gn[:,j+k] += Tk*Pj\n",
    "        else:\n",
    "            # zero order hold\n",
    "            for (k, Tk) in enumerate(Tn):\n",
    "                Gn[:len(x1),k] = Tk*y_target[:-1]\n",
    "            \n",
    "        In_sum = 0\n",
    "        for m in range(M):    \n",
    "            In = calc_integral_n(m, x, xn_cache=xn_cache, In_cache=In_cache) # n x 1\n",
    "            Ia = In[:-1]*Gn[:,m] # (n-1)x1\n",
    "            Ib = In[1:]*Gn[:,m] # (n-1)x1\n",
    "            Iba = Ib-Ia # (n-1)x1\n",
    "            In_sum += np.sum(Iba)\n",
    "        \n",
    "        # An = 1/Kn * int_-1^1 Tm(x)*f(x)/sqrt(1-X^2) dX\n",
    "        # Kn = pi/2 when n != 0\n",
    "        #        pi when n = 0\n",
    "        Kn = np.pi if n == 0 else np.pi/2\n",
    "        An = 1/Kn * In_sum\n",
    "        An_cache[n] = An\n",
    "    \n",
    "    Tn_combined = np.zeros((len(Tn_cache[N-1]),))\n",
    "    for n in range(0, N):\n",
    "        An = An_cache[n]\n",
    "        Tn = calculate_Tn(n, Tn_cache)\n",
    "        Tn_combined[:len(Tn)] += An*Tn\n",
    "    y_pred = plot_Tn(Tn_combined, x)\n",
    "    y_error = y_target-y_pred\n",
    "    \n",
    "    fig, axs = plt.subplots(2, 2, figsize=(10,7))\n",
    "    fig.subplots_adjust(wspace=0.2, hspace=0.4)\n",
    "\n",
    "    ax = axs[0,0]\n",
    "    title_size = 10\n",
    "    ax.plot(x_poly, y_target_poly, label=\"target\")\n",
    "    ax.plot(x_poly, y_poly, linestyle=\"--\", label=\"approximation\")\n",
    "    ax.grid(True)\n",
    "    ax.set_title(\"Polynomial approximation for integration\", size=title_size)\n",
    "    ax.set_xlabel(\"x\")\n",
    "    ax.set_ylabel(\"y\")\n",
    "    ax.legend()\n",
    "    \n",
    "    ax = axs[0,1]\n",
    "    ax.plot(x_poly, y_poly_error)\n",
    "    ax.grid(True)\n",
    "    ax.set_title(\"Polynomial approximation error\", size=title_size)\n",
    "    ax.set_xlabel(\"x\")\n",
    "    ax.set_ylabel(\"y_error\")\n",
    "    \n",
    "    ax = axs[1,0]\n",
    "    ax.plot(x, y_target, label=\"target\")\n",
    "    ax.plot(x, y_pred, linestyle=\"--\", label=\"approximation\")\n",
    "    ax.grid(True)\n",
    "    ax.set_title(\"Chebyshev polynomial approximation\", size=title_size)\n",
    "    ax.set_xlabel(\"x\")\n",
    "    ax.set_ylabel(\"y\")\n",
    "    ax.legend()\n",
    "    \n",
    "    ax = axs[1,1]\n",
    "    ax.plot(x, y_error)\n",
    "    ax.grid(True)\n",
    "    ax.set_title(\"Chebyshev polynomial approximation error\", size=title_size)\n",
    "    ax.set_xlabel(\"x\")\n",
    "    ax.set_ylabel(\"y_error\")\n",
    "\n",
    "    return Tn_combined\n",
    "\n",
    "Tn_partial_sine = f1_calculate_chebyshev_polynomial()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "daf3abe4-d0aa-4303-982a-548586c7f320",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def f2_expand_to_full_polynomial(Tn_partial_sine):\n",
    "    # f(x) = sin(2*pi*x) / x*(x-0.5)*(x+0.5)\n",
    "    # f'(x) = sin(2*pi*x) = x*(x-0.5)*(x+0.5)*Tn(x) = (x^3 - 0.25*x)*Tn(x)\n",
    "    N = len(Tn_partial_sine)\n",
    "    root = 1\n",
    "    Tn_sine = np.zeros((N+3,))\n",
    "    for (power, coefficient) in ((1,-root**2), (3,1)):\n",
    "        Tn_sine[power:N+power] += Tn_partial_sine*coefficient\n",
    "    Tn_sine *= -np.pi/(root**2)\n",
    "    \n",
    "    x = np.linspace(-1,1,1024)\n",
    "    y_target = np.sin(np.pi*x)\n",
    "    y_pred = plot_Tn(Tn_sine, x)\n",
    "    y_error = y_target-y_pred\n",
    "    \n",
    "    fig, axs = plt.subplots(1,2, figsize=(10,3))\n",
    "    title_size = 10\n",
    "    ax = axs[0]\n",
    "    ax.plot(x, y_pred, label=\"target\")\n",
    "    ax.plot(x, y_target, linestyle=\"--\", label=\"approximation\")\n",
    "    ax.grid(True)\n",
    "    ax.set_title(\"Polynomial approximation\", size=title_size)\n",
    "    ax.set_xlabel(\"x\")\n",
    "    ax.set_ylabel(\"y\")\n",
    "    ax.legend()\n",
    "\n",
    "    ax = axs[1]\n",
    "    ax.plot(x, y_error)\n",
    "    ax.grid(True)\n",
    "    ax.set_title(\"Polynomial approximation error\", size=title_size)\n",
    "    ax.set_xlabel(\"x\")\n",
    "    ax.set_ylabel(\"y\")\n",
    "\n",
    "    return Tn_sine\n",
    "\n",
    "Tn_sine = f2_expand_to_full_polynomial(Tn_partial_sine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8ce51034-2642-4319-aa49-a9acca7712e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9999997571463403, -0.6449218592586944, 0.1667099131572423, -0.023664120246180975, 0.0018765462849672444]\n",
      "0.999999757*x^0 + -0.644921859*x^2 + 0.166709913*x^4 + -0.023664120*x^6 + 0.001876546*x^8\n"
     ]
    }
   ],
   "source": [
    "# print polynomial\n",
    "print([x for x in Tn_partial_sine if np.abs(x) > 1e-4])\n",
    "print(' + '.join(f\"{x:.9f}*x^{i}\" for (i,x) in enumerate(Tn_partial_sine) if np.abs(x) > 1e-4))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}

## chebyshev_math_formulas.txt
// Definition of Chebyshev polynomial
Tn(cos(x)) = cos(nx)
T0(cos(x)) = cos(0x) = 1
T1(cos(x)) = cos(x)
T2(cos(x)) = cos(2x) = 2cos(x)^2 - 1
Let X = cos(x)
- T0(X) = 1
- T1(X) = X
- T2(X) = 2X^2 - 1

// Deriving trigonometric identities
e^j(a+b) = e^ja * e^jb
cis(a+b) = cis(a) * cis(b)
cos(a+b) = cos(a)cos(b) - sin(a)sin(b)
sin(a+b) = cos(a)sin(b) + sin(a)cos(b)

e^j(a-b) = e^ja * e^j(-b)
cis(a-b) = cis(a)*cis(-b)
cos(a-b) = cos(a)cos(b) + sin(a)sin(b)
sin(a-b) = -cos(a)sin(b) + sin(a)cos(b)

cos(a+b) + cos(a-b) = 2cos(a)cos(b)
cos(a)cos(b) = 1/2 * [ cos(a+b) + cos(a-b) ]

cos((n+1)x) = cos(x)cos(nx) - sin(x)sin(nx)

// Derive recursive definition for Chebyshev polynomials using trigonometric identities
T_(n+1)(cos(x)) = cos((n+1)x) = cos(x)cos(nx) - sin(x)sin(nx)
T_(n+1)(X) = X*Tn(X) - sin(x)sin(nx)

T_(n-1)(cos(x)) = cos(-x)cos(nx) - sin(-x)sin(nx)
T_(n-1)(X) = X*T_n(X) + sin(x)sin(nx)

T_(n+1)(X) + T_(n-1)(X) = 2*X*T_n(X)
T_(n+1)(X) = 2*X*T_n(X) - T_(n-1)(X)

T3(X) = 2X*T2(X) - T1(X)
T3(X) = 2X*(2X^2-1) - X
T3(X) = 4X^3 - 3X

// Derivation of closed form solutions to cosine integrals
cos(nx)*cos(mx)
= 1/2 * [ cos((n+m)*x) + cos((n-m)*x) ]

- Need to choose a monotonic slice since we are going to use substitution X = cos(x)
- For this to work with an integral the mapping between X <-> cos(x) must be reversible
int_0^pi cos(kx) dx = 0 | Integrals of harmonics are 0
I(x) = int_0^pi cos(nx)cos(mx) dx
= int_0^pi 1/2 * [ cos((n+m)*x) + cos((n-m)*x) ] dx
when n != m, I(x) = int_0^pi 1/2 * [ cos(k1*x) + cos(k2*x) ] dx = 0
when n == m, I(x) = int_0^pi 1/2 * [ cos(k1*x) + cos(0) ] dx = int_0^pi 1/2 dx = pi/2
when n == m == 0, I(x) = int_0^pi 1/2 * [cos(0) + cos(0) ] dx = int_0^pi dx = pi

// Expressing cosine integrals in terms of Chebyshev polynomials
Letting X = cos(x)
dX = -sin(x) dx | X^2 = cos^2(x) = 1-sin^2(x) | sin(x) = sqrt(1-X^2)
dx = -1/sqrt(1-X^2) dX
I(x) = int_1^-1 -Tn(X)*Tm(X)/sqrt(1-X^2) dX
I(x) = int_-1^1 Tn(X)*Tm(X)/sqrt(1-X^2) dX
when n != m, I(x) = 0
when n == m, I(x) = pi/2
when n == m == 0, I(x) = pi

// Using closed form integral solutions to represent arbitrary functions as sum of Chebyshev polynomials
- Approximate f(x) as a sum of Chebyshev polynomials
f(x) = sum_n An*Tn(x)
- Expanding the following integral with f(x) shows we can derive An for Tn(x)
I(x) = int_-1^1 f(x)*Tm(x)/sqrt(1-x^2) dx
I(x) = sum_n An int_-1^1 Tm(x)Tn(x)/sqrt(1-x^2) dx | substitute f(x) = sum_n An*Tn(x) | Notice the nested sum
I(x) = sum_n An In(x) | In(x) = int_-1^1 Tm(x)Tn(x)/sqrt(1-x^2) dx
- Substitute our closed form solutions to integrals involving Chebyshev polynomials
when m != n, In(x) = 0 | This property is called orthoganality
when m == n, In(x) = pi/2
when m == n == 0, In(x) = pi
- We can now solve for An for each unique value of n
- Get rid of integrals with Tm(x)Tn(x) where m != n, since this will evaluate to 0
I(x) = An In(x) | In(x) = int_-1^1 Tn(x)Tn(x)/sqrt(1-x^2) dx
- We have In(x) solved and An is what we want
- Solve for I(x) by using initial definition
I(x) = int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx where m == n | Initial definition
I(x) = An*In(x) = int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx
An = 1/In(x) * int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx
where In(x) = pi/2 for n != 0
      In(x) = pi   for n == 0

// How do we calculate I(x) = int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx ?
- Tm(x) is a Chebyshev polynomial. I.e. Tn(x) = sum_i ai*x^i
- Solve the integral as a sum of small integrals
	- I(x) = sum_j int_aj^bj fj(x)*Tn(x)/sqrt(1-x^2) dx
	- |bj-aj| == very small so we can use approximations for fj(x)
- Use a good approximation for fj(x) in the range x in [aj,bj]
  - Zero order hold: fj(x) = [f(aj)+f(bj)]/2
	- Linear fit: fj(x) = m0 + m1*x where fj(aj)=f(aj) and fj(bj)=f(bj)
	- Quadratic fit: fj(x) = m0 + m1*x + m2*x^2
	- Notice all of these approximations are polynomials
- If we approximate fj(x) between [aj,bj] as a polynomial, and Tn(x) is a Chebyshev polynomial
	- Then Gj(x) = fj(x)*Tn(x) will also be a polynomial
	- Gj(x) = sum_i ai*x^i
I(x) = int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx
= sum_j int_aj^bj fj(x)*Tn(x)/sqrt(1-x^2) dx | x = [aj,bj] is our region where the polynomial fit fj(x) is made
= sum_j int_aj^bj Gj(x)/sqrt(1-x^2) dx
= sum_j int_aj^bj sum_i ai*x^i/sqrt(1-x^2) dx
= sum_j sum_i ai * int_a^b x^i/sqrt(1-x^2) dx | ai is our polynomial coefficient

// Deriving recursive closed form solution to integral of Jn(x) = x^n/sqrt(1-x^2)
Jn(x) = int x^n / sqrt(1-x^2) dx
= int x^(n-1) * x / sqrt(1-x^2) dx
- Using integral by parts: int u dv = uv - int v du
- u = x^(n-1) | du = (n-1)*x^(n-2)
- dv = x / sqrt(1-x^2) | v = -sqrt(1-x^2)
Jn(x) = - x^(n-1) * sqrt(1-x^2) + int sqrt(1-x^2) * (n-1) * x^(n-2) dx
= -x^(n-1) * sqrt(1-x^2) + (n-1) * int x^(n-2) * sqrt(1-x^2) dx
= -x^(n-1) * sqrt(1-x^2) + (n-1) * int x^(n-2) * (1-x^2) / sqrt(1-x^2) dx
= -x^(n-1) * sqrt(1-x^2) - (n-1) * int x^n / sqrt(1-x^2) dx + (n-1) * int x^(n-2) / sqrt(1-x^2) dx
= -x^(n-1) * sqrt(1-x^2) - (n-1) In(x) + (n-1) J_(n-2)(x)
Jn(x) = 1/n * [ -x^(n-1) * sqrt(1-x^2) + (n-1) * J_(n-2)(x) ]

- Get initial solutions for recursive solution
J0(x) = int 1 / sqrt(1-x^2) dx = arcsin(x)
J1(x) = int x / sqrt(1-x^2) dx = -sqrt(1-x^2)

// Putting all together
An = 1/In(x) * int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx
An = 1/In(x) * I(x)
where In(x) = pi/2 for n != 0
      In(x) = pi   for n == 0

I(x) = int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx
= sum_j sum_i ai * int_a^b x^i/sqrt(1-x^2) dx
= sum_j sum_i ai * Ji(x)
- j = index of x = [aj,bj] where fj(x) approximates f(x)
- i = power of polynomial coefficient in fj(x) = sum_i ai*x^i
	// Compiling with clang or gcc
	// clang main.cpp -o main -march=native -O3 -ffast-math -Wextra -Werror -Wunused-parameter -lm
	// Use "-march=native -ffast-math -O3" for faster gradient descent
	// Use "-lm" if linking to glibc math libraries on Linux
	// Remove "-W*" warning flags if you don't need checks

	#define _USE_MATH_DEFINES
	#include <stdio.h>
	#include <cmath>
	#include <vector>

	#define USE_SIGNAL_HANDLER 1

	#if USE_SIGNAL_HANDLER
	static bool is_running = true;
	#if _WIN32
	#define WIN32_LEAN_AND_MEAN
	#define NOMINMAX
	#include <windows.h>
	BOOL WINAPI sighandler(DWORD signum) {
	if (signum == CTRL_C_EVENT) {
	fprintf(stderr, "Signal caught, exiting!\n");
	is_running = false;
	return TRUE;
	}
	return FALSE;
	}
	#else
	#include <errno.h>
	#include <signal.h>
	static void sighandler(int signum) {
	fprintf(stderr, "Signal caught, exiting! (%d)\n", signum);
	is_running = false;
	}
	#endif
	#endif

	// Configuration
	using grad_t = double;
	using coefficient_t = double;
	constexpr size_t PRINT_ITER = 10'000'000;
	constexpr size_t TOTAL_ITER_ERROR_PLATEAU_THRESHOLD = 10'000;

	// Learning rate update rule when minimum error reaches a plateau
	// - If we update than rescale the learning rate
	// - Otherwise we exit early
	constexpr bool IS_UPDATE_LEARNING_RATE = true;
	constexpr grad_t LEARNING_RATE_RESCALER = 1.1;

	// We are solving for a[n] in g(x) = sum a[n]*x^(2n)
	// Where f(x) = h(x)*g(x), where:
	// - f(x) = target function
	// - h(x) = modifier function to reduce complexity of function g(x) needs to solve
	// - g(x) = polynomial that can be calculated using Horner's method
	// https://en.wikipedia.org/wiki/Horner%27s_method

	// Gradient descent hyperparameters
	// - We are approximating f(x) in the range: x = [X_SAMPLE_START, X_SAMPLE_END] with TOTAL_SAMPLES
	// - g(x) = sum a[n]*x^(2n) for n = [0, TOTAL_COEFFICIENTS-1]
	// - learning rate: INITIAL_LEARNING_RATE
	// - Decrease learning rate if unstable
	// - rescaling gradients for de/da[n] by: x^(n*GRAD_RESCALE_MAGNITUDE + GRAD_RESCALE_BIAS)
	// - NOTE: This drastically improves training speed, you should tweak it
	// - Decrease GRAD_RESCALE_MAGNITUDE if training is unstable
	// - NOTE: You should tweak this value before tweaking learning rate

	// Sample functions to approximate
	#if 1
	// y = sin(2pix)
	template <typename T>
	inline static T get_y_target(T x) {
	return std::sin(T(M_PI)2.0x);
	}
	template <typename T>
	inline static T get_h(T x) {
	// constraint so that roots match sin(2pix)
	constexpr T B0 = T(0.5*0.5);
	const T z = x*x;
	return x*(z-B0);
	}
	constexpr size_t TOTAL_SAMPLES = 256;
	constexpr grad_t X_SAMPLE_START = grad_t(0);
	constexpr grad_t X_SAMPLE_END = grad_t(0.5);
	constexpr size_t TOTAL_COEFFICIENTS = 6;
	constexpr grad_t INITIAL_LEARNING_RATE = grad_t(1e0);
	constexpr grad_t GRAD_RESCALE_MAGNITUDE = 4;
	constexpr grad_t GRAD_RESCALE_BIAS = 1;
	#elif 0
	// y = cos(2pix)
	template <typename T>
	inline static T get_y_target(T x) {
	return std::cos(T(M_PI)2.0x);
	}
	template <typename T>
	inline static T get_h(T x) {
	// constraint so that roots match cos(2pix)
	constexpr T B0 = T(0.25*0.25);
	constexpr T B1 = T(0.75*0.75);
	const T z = x*x;
	return (z-B0)*(z-B1);
	}
	constexpr size_t TOTAL_SAMPLES = 256;
	constexpr grad_t X_SAMPLE_START = grad_t(0);
	constexpr grad_t X_SAMPLE_END = grad_t(0.5 + 1e-2);
	constexpr size_t TOTAL_COEFFICIENTS = 6;
	constexpr grad_t INITIAL_LEARNING_RATE = grad_t(1e0);
	constexpr grad_t GRAD_RESCALE_MAGNITUDE = 4;
	constexpr grad_t GRAD_RESCALE_BIAS = 1;
	#else
	// y = x^2 * exp(pix^2) sin(2pix)
	template <typename T>
	inline static T get_y_target(T x) {
	const T z = x*x;
	return zstd::exp(T(M_PI)z)std::sin(2T(M_PI)*x);
	}
	template <typename T>
	inline static T get_h(T x) {
	constexpr T B0 = T(0.5*0.5);
	const T z = x*x;
	return zx(z-B0);
	}
	constexpr size_t TOTAL_SAMPLES = 256;
	constexpr grad_t X_SAMPLE_START = grad_t(0);
	constexpr grad_t X_SAMPLE_END = grad_t(0.5 + 1e-2);
	constexpr size_t TOTAL_COEFFICIENTS = 8;
	constexpr grad_t INITIAL_LEARNING_RATE = grad_t(1e0);
	constexpr grad_t GRAD_RESCALE_MAGNITUDE = 3.6; // needed to be decreased for stable gradient descent
	constexpr grad_t GRAD_RESCALE_BIAS = 1;
	#endif

	inline static coefficient_t get_horner_polynomial(coefficient_t x, coefficient_t* A) {
	// g(x) = sum a[n]*x^(2n)
	// Use Horner's method to calculate this efficiently
	// https://en.wikipedia.org/wiki/Horner%27s_method
	const coefficient_t z = x*x;
	coefficient_t g = A[TOTAL_COEFFICIENTS-1];
	for (size_t i = 1; i < TOTAL_COEFFICIENTS; i++) {
	size_t j = TOTAL_COEFFICIENTS-i-1;
	g = g*z + A[j];
	}
	return g;
	}

	int main(int /argc/, char** /argv/) {
	#if USE_SIGNAL_HANDLER
	#if _WIN32
	SetConsoleCtrlHandler(sighandler, TRUE);
	#else
	struct sigaction sigact;
	sigact.sa_handler = sighandler;
	sigemptyset(&sigact.sa_mask);
	sigact.sa_flags = 0;
	sigaction(SIGINT, &sigact, nullptr);
	sigaction(SIGTERM, &sigact, nullptr);
	sigaction(SIGQUIT, &sigact, nullptr);
	sigaction(SIGPIPE, &sigact, nullptr);
	#endif
	#endif
	coefficient_t poly[TOTAL_COEFFICIENTS] = {coefficient_t(0)};

	static_assert(X_SAMPLE_END > X_SAMPLE_START, "Range of evaluation must be from x_min to x_max");
	constexpr grad_t EVAL_STEP = (X_SAMPLE_END-X_SAMPLE_START)/grad_t(TOTAL_SAMPLES);
	auto X_in = std::vector<grad_t>(TOTAL_SAMPLES);
	auto Y_expected = std::vector<grad_t>(TOTAL_SAMPLES);
	auto H_in = std::vector<grad_t>(TOTAL_SAMPLES);
	for (size_t i = 0; i < TOTAL_SAMPLES; i++) {
	const grad_t x = X_SAMPLE_START + grad_t(i)*EVAL_STEP;
	const grad_t y = get_y_target(x);
	const grad_t h = get_h(x);
	X_in[i] = x;
	Y_expected[i] = y;
	H_in[i] = h;
	}

	// normalised gradients for each term
	// de/da[n] = 2(f-y)h*x^2n
	// = 2e(x)h*x^2n
	// Assume e(x) converges to 0, then e_max = e^2n
	// de/da[n] = 2hx^4n
	// In reality the x^4n factor is approximated as x^(an+b)
	// where a,b are hyperparameters
	grad_t gradient_scale[TOTAL_COEFFICIENTS] = {0.0};
	for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
	grad_t scale = 0.0;
	for (size_t j = 0; j < TOTAL_SAMPLES; j++) {
	const grad_t x = grad_t(X_in[j]);
	const grad_t h = grad_t(H_in[j]);
	const grad_t n = grad_t(i)*GRAD_RESCALE_MAGNITUDE + GRAD_RESCALE_BIAS;
	const grad_t x_n = std::pow(x, n);
	scale += (h*x_n);
	}
	scale = std::abs(scale);
	scale /= grad_t(TOTAL_SAMPLES);
	gradient_scale[i] = grad_t(1) / scale;
	}
	printf("grad_rescale = [");
	for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
	printf("%.2e,", gradient_scale[i]);
	}
	printf("]\n");
	printf("is_update_learning_rate: %u\n", IS_UPDATE_LEARNING_RATE);

	constexpr grad_t NORM_SAMPLES = 1.0f / grad_t(TOTAL_SAMPLES);
	grad_t learning_rate = INITIAL_LEARNING_RATE;
	coefficient_t best_poly[TOTAL_COEFFICIENTS] = {coefficient_t(0)};
	grad_t error_minimum = grad_t(1e6);
	size_t error_minimum_iter = 0;
	size_t total_iter_error_plateau = 0;
	for (size_t iter = 0; ; iter++) {
	grad_t total_error = grad_t(0);
	grad_t gradients[TOTAL_COEFFICIENTS] = {grad_t(0)};
	for (size_t i = 0; i < TOTAL_SAMPLES; i++) {
	const coefficient_t x = X_in[i];
	const coefficient_t y_given = coefficient_t(H_in[i])*get_horner_polynomial(coefficient_t(x), poly);
	const grad_t y_expected = Y_expected[i];
	const grad_t error = grad_t(y_given) - y_expected;
	// gradient descent
	// g(x) = sum a[n]*x^(2n)
	// f(x) = g(x)*h(x)
	// e(x) = [f(x) - y]^2
	// de/df = 2*(f-y)
	// df/dg = h
	// de/dg = de/df * df/dg, chain rule
	// de/dg = 2(f-y)h
	// de/da[n] = de/dg * dg/da[n]
	// dg/da[n] = x^(2n)
	// de/da[n] = 2(f-y)h*x^2n
	const grad_t z = x*x;
	const grad_t h = H_in[i];
	grad_t gradient = errorhgrad_t(2);
	gradients[0] += gradient;
	for (size_t j = 1; j < TOTAL_COEFFICIENTS; j++) {
	gradient *= z;
	gradients[j] += gradient;
	}
	total_error += std::abs(error);
	}

	// normalised error and gradient
	total_error *= NORM_SAMPLES;
	for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
	const grad_t scale = NORM_SAMPLES * gradient_scale[i];
	gradients[i] *= scale;
	}

	// save lowest error polynomial
	if (total_error < error_minimum && !std::isnan(total_error)) {
	error_minimum = total_error;
	error_minimum_iter = iter;
	total_iter_error_plateau = 0;
	for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
	best_poly[i] = poly[i];
	}
	} else {
	total_iter_error_plateau++;
	}

	if (iter % PRINT_ITER == 0) {
	printf("[%zu] error=%.2e, grad=[", iter, total_error);
	for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
	printf("%.2e,", gradients[i]);
	}
	printf("]\n");
	}

	// apply gradients
	bool has_nan = false;
	for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
	const grad_t delta = gradients[i] * learning_rate;
	const grad_t coeff = grad_t(poly[i]) - delta;
	poly[i] = coefficient_t(coeff);
	if (std::abs(coeff) > 1e5f) {
	printf("[%zu] [error] Detected exploding coefficient exiting\n", iter);
	has_nan = true;
	break;
	}
	if (std::isnan(coeff) \|\| std::isinf(coeff)) {
	printf("[%zu] [error] Detected NAN in coefficient exiting\n", iter);
	has_nan = true;
	break;
	}
	}
	if (has_nan) {
	printf("[%zu] [error] Early exit due to bad values, printing them now\n", iter);
	printf(" learning_rate: %.2e\n", learning_rate);
	printf(" grad: [");
	for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
	printf("%.2e,", gradients[i]);
	}
	printf("]\n");
	printf(" poly: [");
	for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
	printf("%.2e,", poly[i]);
	}
	printf("]\n");
	break;
	}
	if (total_iter_error_plateau >= TOTAL_ITER_ERROR_PLATEAU_THRESHOLD) {
	if (IS_UPDATE_LEARNING_RATE) {
	total_iter_error_plateau = 0;
	learning_rate *= LEARNING_RATE_RESCALER;
	} else {
	printf("[%zu] [info] Exiting since error has plateaued after %zu iters\n",
	iter, TOTAL_ITER_ERROR_PLATEAU_THRESHOLD);
	break;
	}
	}
	if (!is_running) break;
	}
	printf("\n[BEST RESULTS]\n");
	printf("step: %zu\n", error_minimum_iter);
	printf("mean_absolute_error: %.2e\n", error_minimum);
	printf("poly[%zu] = {", TOTAL_COEFFICIENTS);
	for (size_t i = 0; i < TOTAL_COEFFICIENTS; i++) {
	constexpr size_t total_dp = (sizeof(coefficient_t) == 4) ? 10 : 16;
	printf("%.*f", int(total_dp), best_poly[i]);
	if (i != TOTAL_COEFFICIENTS-1) {
	printf(",");
	}
	}
	printf("}\n");
	return 0;
	}
	// Definition of Chebyshev polynomial
	Tn(cos(x)) = cos(nx)
	T0(cos(x)) = cos(0x) = 1
	T1(cos(x)) = cos(x)
	T2(cos(x)) = cos(2x) = 2cos(x)^2 - 1
	Let X = cos(x)
	- T0(X) = 1
	- T1(X) = X
	- T2(X) = 2X^2 - 1

	// Deriving trigonometric identities
	e^j(a+b) = e^ja * e^jb
	cis(a+b) = cis(a) * cis(b)
	cos(a+b) = cos(a)cos(b) - sin(a)sin(b)
	sin(a+b) = cos(a)sin(b) + sin(a)cos(b)

	e^j(a-b) = e^ja * e^j(-b)
	cis(a-b) = cis(a)*cis(-b)
	cos(a-b) = cos(a)cos(b) + sin(a)sin(b)
	sin(a-b) = -cos(a)sin(b) + sin(a)cos(b)

	cos(a+b) + cos(a-b) = 2cos(a)cos(b)
	cos(a)cos(b) = 1/2 * [ cos(a+b) + cos(a-b) ]

	cos((n+1)x) = cos(x)cos(nx) - sin(x)sin(nx)

	// Derive recursive definition for Chebyshev polynomials using trigonometric identities
	T_(n+1)(cos(x)) = cos((n+1)x) = cos(x)cos(nx) - sin(x)sin(nx)
	T_(n+1)(X) = X*Tn(X) - sin(x)sin(nx)

	T_(n-1)(cos(x)) = cos(-x)cos(nx) - sin(-x)sin(nx)
	T_(n-1)(X) = X*T_n(X) + sin(x)sin(nx)

	T_(n+1)(X) + T_(n-1)(X) = 2XT_n(X)
	T_(n+1)(X) = 2XT_n(X) - T_(n-1)(X)

	T3(X) = 2X*T2(X) - T1(X)
	T3(X) = 2X*(2X^2-1) - X
	T3(X) = 4X^3 - 3X

	// Derivation of closed form solutions to cosine integrals
	cos(nx)*cos(mx)
	= 1/2 * [ cos((n+m)x) + cos((n-m)x) ]

	- Need to choose a monotonic slice since we are going to use substitution X = cos(x)
	- For this to work with an integral the mapping between X <-> cos(x) must be reversible
	int_0^pi cos(kx) dx = 0 \| Integrals of harmonics are 0
	I(x) = int_0^pi cos(nx)cos(mx) dx
	= int_0^pi 1/2 * [ cos((n+m)x) + cos((n-m)x) ] dx
	when n != m, I(x) = int_0^pi 1/2 * [ cos(k1x) + cos(k2x) ] dx = 0
	when n == m, I(x) = int_0^pi 1/2 * [ cos(k1*x) + cos(0) ] dx = int_0^pi 1/2 dx = pi/2
	when n == m == 0, I(x) = int_0^pi 1/2 * [cos(0) + cos(0) ] dx = int_0^pi dx = pi

	// Expressing cosine integrals in terms of Chebyshev polynomials
	Letting X = cos(x)
	dX = -sin(x) dx \| X^2 = cos^2(x) = 1-sin^2(x) \| sin(x) = sqrt(1-X^2)
	dx = -1/sqrt(1-X^2) dX
	I(x) = int_1^-1 -Tn(X)*Tm(X)/sqrt(1-X^2) dX
	I(x) = int_-1^1 Tn(X)*Tm(X)/sqrt(1-X^2) dX
	when n != m, I(x) = 0
	when n == m, I(x) = pi/2
	when n == m == 0, I(x) = pi

	// Using closed form integral solutions to represent arbitrary functions as sum of Chebyshev polynomials
	- Approximate f(x) as a sum of Chebyshev polynomials
	f(x) = sum_n An*Tn(x)
	- Expanding the following integral with f(x) shows we can derive An for Tn(x)
	I(x) = int_-1^1 f(x)*Tm(x)/sqrt(1-x^2) dx
	I(x) = sum_n An int_-1^1 Tm(x)Tn(x)/sqrt(1-x^2) dx \| substitute f(x) = sum_n An*Tn(x) \| Notice the nested sum
	I(x) = sum_n An In(x) \| In(x) = int_-1^1 Tm(x)Tn(x)/sqrt(1-x^2) dx
	- Substitute our closed form solutions to integrals involving Chebyshev polynomials
	when m != n, In(x) = 0 \| This property is called orthoganality
	when m == n, In(x) = pi/2
	when m == n == 0, In(x) = pi
	- We can now solve for An for each unique value of n
	- Get rid of integrals with Tm(x)Tn(x) where m != n, since this will evaluate to 0
	I(x) = An In(x) \| In(x) = int_-1^1 Tn(x)Tn(x)/sqrt(1-x^2) dx
	- We have In(x) solved and An is what we want
	- Solve for I(x) by using initial definition
	I(x) = int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx where m == n \| Initial definition
	I(x) = AnIn(x) = int_-1^1 f(x)Tn(x)/sqrt(1-x^2) dx
	An = 1/In(x) * int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx
	where In(x) = pi/2 for n != 0
	In(x) = pi for n == 0

	// How do we calculate I(x) = int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx ?
	- Tm(x) is a Chebyshev polynomial. I.e. Tn(x) = sum_i ai*x^i
	- Solve the integral as a sum of small integrals
	- I(x) = sum_j int_aj^bj fj(x)*Tn(x)/sqrt(1-x^2) dx
	- \|bj-aj\| == very small so we can use approximations for fj(x)
	- Use a good approximation for fj(x) in the range x in [aj,bj]
	- Zero order hold: fj(x) = [f(aj)+f(bj)]/2
	- Linear fit: fj(x) = m0 + m1*x where fj(aj)=f(aj) and fj(bj)=f(bj)
	- Quadratic fit: fj(x) = m0 + m1x + m2x^2
	- Notice all of these approximations are polynomials
	- If we approximate fj(x) between [aj,bj] as a polynomial, and Tn(x) is a Chebyshev polynomial
	- Then Gj(x) = fj(x)*Tn(x) will also be a polynomial
	- Gj(x) = sum_i ai*x^i
	I(x) = int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx
	= sum_j int_aj^bj fj(x)*Tn(x)/sqrt(1-x^2) dx \| x = [aj,bj] is our region where the polynomial fit fj(x) is made
	= sum_j int_aj^bj Gj(x)/sqrt(1-x^2) dx
	= sum_j int_aj^bj sum_i ai*x^i/sqrt(1-x^2) dx
	= sum_j sum_i ai * int_a^b x^i/sqrt(1-x^2) dx \| ai is our polynomial coefficient

	// Deriving recursive closed form solution to integral of Jn(x) = x^n/sqrt(1-x^2)
	Jn(x) = int x^n / sqrt(1-x^2) dx
	= int x^(n-1) * x / sqrt(1-x^2) dx
	- Using integral by parts: int u dv = uv - int v du
	- u = x^(n-1) \| du = (n-1)*x^(n-2)
	- dv = x / sqrt(1-x^2) \| v = -sqrt(1-x^2)
	Jn(x) = - x^(n-1) * sqrt(1-x^2) + int sqrt(1-x^2) * (n-1) * x^(n-2) dx
	= -x^(n-1) * sqrt(1-x^2) + (n-1) * int x^(n-2) * sqrt(1-x^2) dx
	= -x^(n-1) * sqrt(1-x^2) + (n-1) * int x^(n-2) * (1-x^2) / sqrt(1-x^2) dx
	= -x^(n-1) * sqrt(1-x^2) - (n-1) * int x^n / sqrt(1-x^2) dx + (n-1) * int x^(n-2) / sqrt(1-x^2) dx
	= -x^(n-1) * sqrt(1-x^2) - (n-1) In(x) + (n-1) J_(n-2)(x)
	Jn(x) = 1/n * [ -x^(n-1) * sqrt(1-x^2) + (n-1) * J_(n-2)(x) ]

	- Get initial solutions for recursive solution
	J0(x) = int 1 / sqrt(1-x^2) dx = arcsin(x)
	J1(x) = int x / sqrt(1-x^2) dx = -sqrt(1-x^2)

	// Putting all together
	An = 1/In(x) * int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx
	An = 1/In(x) * I(x)
	where In(x) = pi/2 for n != 0
	In(x) = pi for n == 0

	I(x) = int_-1^1 f(x)*Tn(x)/sqrt(1-x^2) dx
	= sum_j sum_i ai * int_a^b x^i/sqrt(1-x^2) dx
	= sum_j sum_i ai * Ji(x)
	- j = index of x = [aj,bj] where fj(x) approximates f(x)
	- i = power of polynomial coefficient in fj(x) = sum_i ai*x^i
N	MAE	Coefficients
6	`7.07e-10`	`{-25.1327411142213464,64.8358266034100694,-67.0768851968012996,38.4999814590310407,-14.0736995967404166,3.2086237284325541}`
5	`6.01e-8`	`{-25.1327327703024501,64.8348800694709126,-67.0481124846729131,38.1547044862267200,-12.3089616248433558}`
N	MAE	Coefficients
6	`2.47e-8`	`{-25.1327419281,64.8358230591,-67.0768585205,38.5037078857,-14.1102266312,3.2983388901}`
5	`6.32e-8`	`{-25.1327323914,64.8348770142,-67.0481109619,38.1546096802,-12.3083391190}`