MAE_Calculation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.5776542888734597, 0.5555555555555556]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ORIGINAL MISCLASSIFIED INCLUDED AS MAX ERROR \n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Original import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random \n",
    "\n",
    "def ORIG_1(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #middle third of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),int(fbm_section)):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        #rightmost third of matrix (random signals)\n",
    "        for l in range(int(fbm_section), N2):\n",
    "            Hurst_rand = 0 #expected Hurst for random signal?\n",
    "            Hurst_expected[i][l] = Hurst_rand\n",
    "            Sig_class_expected[i][l] = 3 #outside model\n",
    "            #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "            Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "    print(type(Signal_matrix))\n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    \n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 1\n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ORIG_1(3,3,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n",
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n",
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n",
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.0, 0.0]"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ORIGINAL MISCLASSIFIED INCLUDED \n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Original import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ORIG_2(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #middle third of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),int(fbm_section)):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "        #rightmost third of matrix (random signals)\n",
    "        for l in range(N1, N2):\n",
    "            Hurst_rand = 0.5 #expected Hurst for random signal?\n",
    "            Hurst_expected[i][l] = Hurst_rand\n",
    "            Sig_class_expected[i][l] = 3 #outside model\n",
    "            #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "            Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "           \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    \n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    print(Sig_class_expected)\n",
    "    print(Sig_class_actual)\n",
    "    print(Hurst_expected)\n",
    "    print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "\n",
    "ORIG_2(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ipynb.fs.defs.Fractool_Current:92: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "ipynb.fs.defs.Fractool_Current:93: ComplexWarning: Casting complex values to real discards the imaginary part\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.059947596907798696, 0.6336088154269972]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ORIGINAL MISCLASSIFIED EXCLUDED \n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Current import FracTool\n",
    "#from ipynb.fs.defs.Fractool_Original import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ORIG_3(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #middle third of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),int(fbm_section)):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        #rightmost third of matrix (random signals)\n",
    "        for l in range(int(fbm_section), N2):\n",
    "            Hurst_rand = 0 #expected Hurst for random signal?\n",
    "            Hurst_expected[i][l] = Hurst_rand\n",
    "            Sig_class_expected[i][l] = 3 #outside model\n",
    "            #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "            Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "    \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    \n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 0\n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ORIG_3(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5159925021650476, 0.4573002754820937]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ZERO_PADDING MISCLASSIFIED INCLUDED AS MAX ERROR \n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Zero_Padding import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ZERO_PAD_1(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #middle third of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),int(fbm_section)):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        #rightmost third of matrix (random signals)\n",
    "        for l in range(int(fbm_section), N2):\n",
    "            Hurst_rand = 0 #expected Hurst for random signal?\n",
    "            Hurst_expected[i][l] = Hurst_rand\n",
    "            Sig_class_expected[i][l] = 3 #outside model\n",
    "            #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "            Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "    \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    \n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 1\n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ZERO_PAD_1(33,33,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 2. 2. 3. 3.]\n",
      " [0. 0. 2. 2. 3. 3.]\n",
      " [0. 0. 2. 2. 3. 3.]\n",
      " [0. 0. 2. 2. 3. 3.]\n",
      " [0. 0. 2. 2. 3. 3.]\n",
      " [0. 0. 2. 2. 3. 3.]]\n",
      "[[0. 0. 2. 2. 2. 0.]\n",
      " [0. 0. 2. 2. 2. 0.]\n",
      " [2. 2. 2. 2. 2. 0.]\n",
      " [0. 0. 2. 2. 0. 2.]\n",
      " [0. 0. 2. 2. 2. 2.]\n",
      " [0. 2. 2. 2. 0. 2.]]\n",
      "[[0.3425201  0.35481057 0.858455   0.70046819 0.5        0.5       ]\n",
      " [0.66475218 0.67728844 0.50193275 0.8873979  0.5        0.5       ]\n",
      " [0.34939811 0.09448165 0.53035307 0.75994172 0.5        0.5       ]\n",
      " [0.86953645 0.59700235 0.88954427 0.20411706 0.5        0.5       ]\n",
      " [0.63446145 0.41376928 0.98146653 0.28779266 0.5        0.5       ]\n",
      " [0.86130491 0.23306336 0.95187214 0.22026618 0.5        0.5       ]]\n",
      "[[0.63959036 0.69032366 0.78358075 0.66896774 0.16803694 0.47089114]\n",
      " [0.66493075 0.72563226 0.56639984 0.76470886 0.08967824 0.63672101]\n",
      " [0.29679626 0.11142297 0.41768776 0.65858644 0.11545898 0.67425568]\n",
      " [0.79515763 0.7724728  0.66893488 0.3528204  0.73281439 0.16906354]\n",
      " [0.80566986 0.58906305 0.70084616 0.31376452 0.12513476 0.06288379]\n",
      " [0.85867718 0.27642546 0.79571672 0.37825385 0.63808653 0.2100274 ]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.17114701381812245, 0.4166666666666667]"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ZERO_PADDING MISCLASSIFIED INCLUDED \n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Zero_Padding import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ZERO_PAD_2(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #middle third of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),int(fbm_section)):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        #rightmost third of matrix (random signals)\n",
    "        for l in range(int(fbm_section), N2):\n",
    "            Hurst_rand = 0.5 #expected Hurst for random signal?\n",
    "            Hurst_expected[i][l] = Hurst_rand\n",
    "            Sig_class_expected[i][l] = 3 #outside model\n",
    "            #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "            Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "    \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    \n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    \n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ZERO_PAD_2(6,6,300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.054576544945283356, 0.4820936639118457]"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ZERO_PADDING MISCLASSIFIED EXCLUDED \n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Zero_Padding import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ZERO_PAD_3(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #middle third of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),int(fbm_section)):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        #rightmost third of matrix (random signals)\n",
    "        for l in range(int(fbm_section), N2):\n",
    "            Hurst_rand = 0 #expected Hurst for random signal?\n",
    "            Hurst_expected[i][l] = Hurst_rand\n",
    "            Sig_class_expected[i][l] = 3 #outside model\n",
    "            #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "            Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "    \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    \n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 0\n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ZERO_PAD_3(33,33,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.6961490673500167, 0.6556473829201102]"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on FREQ_FILTER MISCLASSIFIED INCLUDED AS MAX ERROR \n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Freq_Filter import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def FREQ_FILT_1(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #middle third of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),int(fbm_section)):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        #rightmost third of matrix (random signals)\n",
    "        for l in range(int(fbm_section), N2):\n",
    "            Hurst_rand = 0 #expected Hurst for random signal?\n",
    "            Hurst_expected[i][l] = Hurst_rand\n",
    "            Sig_class_expected[i][l] = 3 #outside model\n",
    "            #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "            Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "    \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    \n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 1\n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "FREQ_FILT_1(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.29247089223587436, 0.6584022038567493]"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on FREQ_FILT MISCLASSIFIED INCLUDED \n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Freq_Filter import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def FREQ_FILT_2(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #middle third of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),int(fbm_section)):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        #rightmost third of matrix (random signals)\n",
    "        for l in range(int(fbm_section), N2):\n",
    "            Hurst_rand = 0.5 #expected Hurst for random signal?\n",
    "            Hurst_expected[i][l] = Hurst_rand\n",
    "            Sig_class_expected[i][l] = 3 #outside model\n",
    "            #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "            Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "    \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    \n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "FREQ_FILT_2(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 2. 2. 2. 3. 3. 3.]\n",
      " [0. 0. 0. 2. 2. 2. 3. 3. 3.]\n",
      " [0. 0. 0. 2. 2. 2. 3. 3. 3.]\n",
      " [0. 0. 0. 2. 2. 2. 3. 3. 3.]\n",
      " [0. 0. 0. 2. 2. 2. 3. 3. 3.]\n",
      " [0. 0. 0. 2. 2. 2. 3. 3. 3.]\n",
      " [0. 0. 0. 2. 2. 2. 3. 3. 3.]\n",
      " [0. 0. 0. 2. 2. 2. 3. 3. 3.]\n",
      " [0. 0. 0. 2. 2. 2. 3. 3. 3.]]\n",
      "[[0. 0. 0. 2. 2. 2. 0. 0. 0.]\n",
      " [3. 0. 0. 2. 2. 2. 0. 0. 0.]\n",
      " [0. 0. 0. 2. 2. 2. 0. 0. 0.]\n",
      " [0. 0. 3. 2. 0. 2. 0. 0. 0.]\n",
      " [1. 3. 0. 2. 2. 2. 0. 0. 0.]\n",
      " [3. 0. 0. 2. 2. 0. 0. 0. 0.]\n",
      " [0. 2. 2. 2. 2. 2. 0. 0. 0.]\n",
      " [0. 3. 0. 2. 2. 2. 0. 0. 0.]\n",
      " [0. 0. 3. 2. 2. 2. 0. 0. 0.]]\n",
      "[[0.22277855 0.13796916 0.24372153 0.17551787 0.47992729 0.37455531\n",
      "  0.         0.         0.        ]\n",
      " [0.         0.54109059 0.71991802 0.42172797 0.86419222 0.16584539\n",
      "  0.         0.         0.        ]\n",
      " [0.47577031 0.79602483 0.43669099 0.68977867 0.25599902 0.33770622\n",
      "  0.         0.         0.        ]\n",
      " [0.03543098 0.45596502 0.         0.78585394 0.         0.48283274\n",
      "  0.         0.         0.        ]\n",
      " [0.         0.         0.30018778 0.58156661 0.27638183 0.92832669\n",
      "  0.         0.         0.        ]\n",
      " [0.         0.49119991 0.71271106 0.42659826 0.96335465 0.\n",
      "  0.         0.         0.        ]\n",
      " [0.46062803 0.         0.         0.20527672 0.24105588 0.23222132\n",
      "  0.         0.         0.        ]\n",
      " [0.59248207 0.         0.48815929 0.99127119 0.72859813 0.28792458\n",
      "  0.         0.         0.        ]\n",
      " [0.72895505 0.64496457 0.         0.94572962 0.98746721 0.33452486\n",
      "  0.         0.         0.        ]]\n",
      "[[ 0.2196717   0.19588293  0.38044799  0.21926732  0.53091371  0.3621152\n",
      "   0.          0.          0.        ]\n",
      " [ 0.          0.52742371  0.30051856  0.59862724  0.96037636  0.15456589\n",
      "   0.          0.          0.        ]\n",
      " [ 0.61738546  0.77694627  0.30220806  0.3866512   0.29765846  0.29733104\n",
      "   0.          0.          0.        ]\n",
      " [-0.04445904  0.47040841  0.          0.65742403  0.          0.42839999\n",
      "   0.          0.          0.        ]\n",
      " [ 0.          0.          0.25390824  0.61511597  0.29400661  0.71884101\n",
      "   0.          0.          0.        ]\n",
      " [ 0.          0.45264874  0.5298091   0.48638818  0.80905079  0.\n",
      "   0.          0.          0.        ]\n",
      " [ 0.3381926   0.          0.          0.32128321  0.19735424  0.24810404\n",
      "   0.          0.          0.        ]\n",
      " [ 0.47029456  0.          0.55163787  0.81724019  0.70843029  0.33330728\n",
      "   0.          0.          0.        ]\n",
      " [ 0.44178493  0.66995856  0.          0.9424931   0.92488966  0.32542314\n",
      "   0.          0.          0.        ]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.04731761925174519, 0.4691358024691358]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on FREQ_FILT MISCLASSIFIED EXCLUDED \n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Freq_Filter import FracTool\n",
    "\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def FREQ_FILT_3(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #middle third of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),int(fbm_section)):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        #rightmost third of matrix (random signals)\n",
    "        for l in range(int(fbm_section), N2):\n",
    "            Hurst_rand = 0 #expected Hurst for random signal?\n",
    "            Hurst_expected[i][l] = Hurst_rand\n",
    "            Sig_class_expected[i][l] = 3 #outside model\n",
    "            #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "            Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "    \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m], 2.4)\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    \n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 0\n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    print(Sig_class_expected)\n",
    "    print(Sig_class_actual)\n",
    "    print(Hurst_expected)\n",
    "    print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "FREQ_FILT_3(9,9,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.7255968434420017, 0.6694214876033058]"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ORIG MISCLASSIFIED INCLUDED MAX ERROR BUT NO RAND\n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Original import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ORIG_4(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/2) #end of leftmost third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #right half of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),N2):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    Signal_matrix = []\n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 1\n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    #print(Sig_class_expected)\n",
    "    #print(Sig_class_actual)\n",
    "    #print(Hurst_expected)\n",
    "    #print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ORIG_4(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.4230622459745016, 0.650137741046832]"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ORIG MISCLASSIFIED INCLUDED BUT NO RAND\n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Original import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ORIG_5(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/2) #end of leftmost third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #right half of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),N2):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    Signal_matrix = []\n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "               \n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    #print(Sig_class_expected)\n",
    "    #print(Sig_class_actual)\n",
    "    #print(Hurst_expected)\n",
    "    #print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ORIG_5(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.06311145416080956, 0.6483011937557392]"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ORIG MISCLASSIFIED EXCLUDED BUT NO RAND\n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Original import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ORIG_6(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/2) #end of leftmost third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #right half of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),N2):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    Signal_matrix = []\n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 0\n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    #print(Sig_class_expected)\n",
    "    #print(Sig_class_actual)\n",
    "    #print(Hurst_expected)\n",
    "    #print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ORIG_6(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.2727707777242223, 0.1891643709825528]"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ZERO_PADDING MISCLASSIFIED INCLUDED MAX ERROR BUT NO RAND\n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Zero_Padding import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ZERO_PAD_4(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/2) #end of leftmost third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #right half of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),N2):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    Signal_matrix = []\n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 1\n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    #print(Sig_class_expected)\n",
    "    #print(Sig_class_actual)\n",
    "    #print(Hurst_expected)\n",
    "    #print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ZERO_PAD_4(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.19271943653912027, 0.21120293847566574]"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ZERO_PADDING MISCLASSIFIED INCLUDED BUT NO RAND\n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Zero_Padding import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ZERO_PAD_5(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/2) #end of leftmost third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #right half of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),N2):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    Signal_matrix = []\n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "               \n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    #print(Sig_class_expected)\n",
    "    #print(Sig_class_actual)\n",
    "    #print(Hurst_expected)\n",
    "    #print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ZERO_PAD_5(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.08810925482799019, 0.20385674931129477]"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on ZERO_PADDING MISCLASSIFIED EXCLUDED BUT NO RAND\n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Zero_Padding import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def ZERO_PAD_6(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/2) #end of leftmost third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #right half of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),N2):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    Signal_matrix = []\n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 0\n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    #print(Sig_class_expected)\n",
    "    #print(Sig_class_actual)\n",
    "    #print(Hurst_expected)\n",
    "    #print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "ZERO_PAD_6(33,33,1400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5456858073369049, 0.4839302112029385]"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on FREQ_FILTER MISCLASSIFIED INCLUDED MAX ERROR BUT NO RAND\n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Freq_Filter import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def FREQ_FILT_4(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/2) #end of leftmost third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #right half of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),N2):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    Signal_matrix = []\n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 1\n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    #print(Sig_class_expected)\n",
    "    #print(Sig_class_actual)\n",
    "    #print(Hurst_expected)\n",
    "    #print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "FREQ_FILT_4(33,33,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]]\n",
      "[[0. 2. 0. 3. 1. 2. 2. 2. 2. 2.]\n",
      " [1. 0. 0. 0. 0. 0. 2. 2. 2. 2.]\n",
      " [0. 0. 1. 0. 0. 2. 2. 2. 2. 1.]\n",
      " [2. 0. 2. 0. 3. 2. 0. 2. 2. 1.]\n",
      " [0. 0. 0. 0. 0. 0. 2. 2. 2. 2.]\n",
      " [2. 0. 0. 3. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 1. 2. 2. 2. 2. 2.]\n",
      " [3. 0. 3. 2. 0. 0. 2. 2. 2. 1.]\n",
      " [3. 0. 2. 0. 0. 2. 2. 2. 0. 2.]\n",
      " [0. 3. 3. 2. 3. 2. 2. 2. 2. 2.]]\n",
      "[[0.31783122 0.96393779 0.99153412 0.03942253 0.858361   0.36573313\n",
      "  0.83440463 0.94487181 0.81338512 0.50344565]\n",
      " [0.72002925 0.48615514 0.78329003 0.30886449 0.73586867 0.0077404\n",
      "  0.26705894 0.22387955 0.82079662 0.93488522]\n",
      " [0.69369007 0.38457975 0.9455395  0.38504569 0.44461717 0.75127169\n",
      "  0.2726484  0.56245061 0.21411848 0.14070192]\n",
      " [0.97380332 0.50005846 0.87113331 0.592566   0.19071432 0.66145053\n",
      "  0.00229169 0.56167912 0.15339425 0.07382147]\n",
      " [0.54161632 0.18418811 0.44518717 0.62383386 0.36635888 0.07954143\n",
      "  0.96691117 0.95141821 0.49180272 0.71560271]\n",
      " [0.96967899 0.41406759 0.79489999 0.06522192 0.77037392 0.4195114\n",
      "  0.68579486 0.10312032 0.97029348 0.51266964]\n",
      " [0.27857552 0.60926324 0.5191348  0.46345183 0.81696093 0.54125743\n",
      "  0.13566981 0.63685479 0.16460804 0.56361323]\n",
      " [0.19014454 0.78095048 0.04946923 0.96713221 0.17819325 0.03693143\n",
      "  0.87338042 0.21274543 0.33032858 0.04304098]\n",
      " [0.05297259 0.110487   0.87372538 0.54946908 0.24106227 0.91862412\n",
      "  0.4782702  0.62760889 0.05157368 0.62537378]\n",
      " [0.54733646 0.0942177  0.13851813 0.80334601 0.04094298 0.82082741\n",
      "  0.51435134 0.67732517 0.73761085 0.20963952]]\n",
      "[[0.3427304  0.16769561 0.78550552 0.         0.         0.47060283\n",
      "  0.7369358  0.5660211  0.6419426  0.54075488]\n",
      " [0.         0.54084316 0.65476885 0.28420937 0.67396086 0.4272543\n",
      "  0.67958485 0.16627429 0.63772161 0.78329592]\n",
      " [0.75114767 0.37677006 0.         0.48092747 0.3710692  0.67813139\n",
      "  0.39436224 0.44937458 0.4772154  0.        ]\n",
      " [0.2205509  0.37333286 0.15507074 0.68811915 0.         0.6815197\n",
      "  0.36972934 0.71940499 0.17443564 0.        ]\n",
      " [0.54485455 0.04148459 0.43056742 0.66803792 0.31137696 0.48621659\n",
      "  0.74044153 0.71520852 0.46703112 0.58538569]\n",
      " [0.12850803 0.55938675 0.72616018 0.         0.61263886 0.36696858\n",
      "  0.79543048 0.46778954 0.79296264 0.45430545]\n",
      " [0.24989623 0.53749411 0.69131394 0.45155189 0.         0.51941341\n",
      "  0.19687244 0.61773519 0.20951306 0.59358761]\n",
      " [0.         0.60462694 0.         0.19513571 0.20401569 0.73463484\n",
      "  0.64391439 0.25592437 0.32802714 0.        ]\n",
      " [0.         0.04947495 0.23986092 0.39911419 0.12544897 0.69606297\n",
      "  0.47486493 0.86634496 0.74330157 0.66716813]\n",
      " [0.33848735 0.         0.         0.10602361 0.         0.80272418\n",
      "  0.3339051  0.64086107 0.73942293 0.18261588]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.19831917349680872, 0.28]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on FREQ_FILTER MISCLASSIFIED INCLUDED BUT NO RAND\n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Freq_Filter import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def FREQ_FILT_5(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/2) #end of leftmost third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #right half of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),N2):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    Signal_matrix = []\n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "               \n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    print(Sig_class_expected)\n",
    "    print(Sig_class_actual)\n",
    "    print(Hurst_expected)\n",
    "    print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "FREQ_FILT_5(10,10,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 2. 2. 2. 2.]]\n",
      "[[0. 3. 1. 0. 0. 2. 2. 2. 2. 2.]\n",
      " [0. 0. 0. 2. 3. 2. 2. 2. 2. 0.]\n",
      " [0. 3. 0. 3. 0. 2. 2. 2. 2. 2.]\n",
      " [2. 0. 3. 2. 3. 2. 2. 0. 2. 2.]\n",
      " [0. 0. 0. 0. 0. 2. 0. 2. 2. 2.]\n",
      " [3. 1. 0. 2. 3. 2. 2. 2. 2. 2.]\n",
      " [1. 0. 0. 0. 0. 0. 2. 2. 0. 2.]\n",
      " [0. 0. 0. 0. 1. 1. 2. 2. 2. 2.]\n",
      " [1. 0. 0. 0. 2. 2. 2. 2. 2. 2.]\n",
      " [0. 1. 0. 0. 0. 2. 2. 0. 2. 1.]]\n",
      "[[0.32727396 0.         0.         0.22898213 0.75455457 0.5251272\n",
      "  0.26994326 0.3224543  0.31616327 0.78194537]\n",
      " [0.61108749 0.53500303 0.7001394  0.         0.         0.40539237\n",
      "  0.22957248 0.49188393 0.54658569 0.        ]\n",
      " [0.36518259 0.         0.59899591 0.         0.36439513 0.25668791\n",
      "  0.43923396 0.25886437 0.21271298 0.52591535]\n",
      " [0.         0.53428757 0.         0.         0.         0.85232888\n",
      "  0.19616857 0.         0.34552999 0.92810026]\n",
      " [0.33327899 0.53286161 0.32061558 0.7990835  0.24829123 0.5865605\n",
      "  0.         0.99722959 0.74688945 0.13126115]\n",
      " [0.         0.         0.43588907 0.         0.         0.58043681\n",
      "  0.2434357  0.81059303 0.62734717 0.56975711]\n",
      " [0.         0.48569071 0.67355893 0.1926499  0.19576829 0.\n",
      "  0.84156159 0.995802   0.         0.72023528]\n",
      " [0.31004202 0.74242942 0.28118448 0.67462424 0.         0.\n",
      "  0.80451301 0.84425097 0.48480312 0.76743151]\n",
      " [0.         0.21922291 0.68580896 0.30814901 0.         0.36955929\n",
      "  0.20756    0.76633697 0.53622812 0.67858475]\n",
      " [0.43813828 0.         0.5938828  0.35689385 0.51439813 0.15625988\n",
      "  0.17313289 0.         0.21465578 0.        ]]\n",
      "[[0.41913241 0.         0.         0.24861197 0.73092301 0.42280519\n",
      "  0.60787615 0.35071841 0.36639711 0.65483198]\n",
      " [0.63113303 0.42320338 0.77856346 0.         0.         0.4835212\n",
      "  0.14717035 0.44552862 0.52147302 0.        ]\n",
      " [0.39254655 0.         0.67217341 0.         0.36663476 0.27409903\n",
      "  0.51594614 0.25444137 0.49736325 0.52377929]\n",
      " [0.         0.43574447 0.         0.         0.         0.654991\n",
      "  0.1900356  0.         0.34457486 0.69011088]\n",
      " [0.39503281 0.59052825 0.3554059  0.82298006 0.18112984 0.57863551\n",
      "  0.         0.73103549 0.64252808 0.42817577]\n",
      " [0.         0.         0.46443176 0.         0.         0.52096111\n",
      "  0.28796978 0.81673106 0.56895621 0.6133    ]\n",
      " [0.         0.43212543 0.64437976 0.12548829 0.14435306 0.\n",
      "  0.69849846 0.74328786 0.         0.58210222]\n",
      " [0.38958246 0.74536893 0.25055279 0.67035818 0.         0.\n",
      "  0.64124452 0.80678477 0.41175099 0.65129019]\n",
      " [0.         0.14961091 0.72254242 0.20179178 0.         0.44212588\n",
      "  0.17155079 0.58975193 0.46981333 0.57699066]\n",
      " [0.47822178 0.         0.61598216 0.35424669 0.45363497 0.56875947\n",
      "  0.57647583 0.         0.19225437 0.        ]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.06285661596219938, 0.27]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculate MAE on FREQ_FILT MISCLASSIFIED EXCLUDED BUT NO RAND\n",
    "\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Freq_Filter import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "\n",
    "def FREQ_FILT_6(N1,N2,N3):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "    #create arrays of expected Hurst and class (if interested in class as well)\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/2) #end of leftmost third of columns of matrix\n",
    "   \n",
    "    for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "        for j in range(0,int(fgn_section)):\n",
    "            Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "            Hurst_expected[i][j] = Hurst_fgn\n",
    "            Sig_class_expected[i][j] = 0 #fGn class\n",
    "            #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "            Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        \n",
    "        #right half of matrix (fBm signals)\n",
    "        for k in range(int(fgn_section),N2):\n",
    "            Hurst_fbm = random.random()\n",
    "            Hurst_expected[i][k] = Hurst_fbm\n",
    "            Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "            Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    for n in range(N1): \n",
    "        for m in range(N2):\n",
    "            result = FracTool(Signal_matrix[n,m], 2.4)\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "            Hurst_actual[n,m] = result[1] \n",
    "            Sig_class_actual[n,m] = result[0] #comment out if only interested in Hurst MSE\n",
    "    \n",
    "    Signal_matrix = []\n",
    "    Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "\n",
    "    summation = 0\n",
    "    misclassified_total = 0\n",
    "    #if want to compute MAE of whole matrix, use range(N1) for outer for loop \n",
    "    #if want to compute MAE of fGn only, use range(int(fgn_section))\n",
    "    #if want to compute MAE of fBm only, use range(int(fgn_section),int(fbm_section))\n",
    "    #if want to compute MAE of random signals only, use range(int(fbm_section), N2)\n",
    "    for x in range(N1):\n",
    "        for y in range(N2):\n",
    "            if ((Sig_class_actual[x,y] != Sig_class_expected[x,y])):\n",
    "                misclassified_total = misclassified_total + 1\n",
    "                Hurst_actual[x,y] = 0\n",
    "                Hurst_expected[x,y] = 0\n",
    "              \n",
    "                \n",
    "            diff = abs((Hurst_actual[x,y] - Hurst_expected[x,y]))\n",
    "            summation = summation + diff\n",
    "    \n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE = summation/(N1*N2)  #need to divide by number that is included - change if only looking at specific section of matrix\n",
    "    print(Sig_class_expected)\n",
    "    print(Sig_class_actual)\n",
    "    print(Hurst_expected)\n",
    "    print(Hurst_actual)\n",
    "    return [MAE, Misclassified_Rate]\n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points\n",
    "FREQ_FILT_6(10,10,700)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calculate MAE on ZERO_PADDING USING MULTIPROCESSOR - WIP\n",
    "from fbm import fbm, fgn, times\n",
    "import numpy as np\n",
    "from ipynb.fs.defs.Fractool_Zero_Padding import FracTool\n",
    "import sklearn\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import random as random\n",
    "import multiprocessing\n",
    "\n",
    " #create arrays of expected Hurst and class (if interested in class as well)\n",
    "\n",
    "def MAE(i):\n",
    "    '''This function generates a matrix of known Hurst values and calculates the MSE of the expected Hurst and the \n",
    "    actual Hurst outputted by FracTool. The leftmost third of the matrix are fGn signals, the middle third are fBm \n",
    "    signals, and the last third are random arrays. \n",
    "    N1 = number of rows in matrix\n",
    "    N2 = number of columns in matrix\n",
    "    N3 = number of time-points in signal (3rd dimension in matrix)\n",
    "    '''\n",
    "    #i = N1 = 6\n",
    "    \n",
    "    #first generate an matrix with known Hurst values and signal class\n",
    "    \n",
    "   \n",
    "    \n",
    "    #for i in range(N1):\n",
    "        #leftmost third of matrix (fGn signals)\n",
    "    for j in range(0,int(fgn_section)):\n",
    "        Hurst_fgn = random.random() #generates random number between 0 and 1 (random Hurst value)\n",
    "        Hurst_expected[i][j] = Hurst_fgn\n",
    "        Sig_class_expected[i][j] = 0 #fGn class\n",
    "        #generate fGn signal with random Hurst at each element in first third of matrix\n",
    "        Signal_matrix[i][j] = fgn(n=N3, hurst = Hurst_fgn, length=1, method='daviesharte')\n",
    "        result = FracTool(Signal_matrix[i,j])\n",
    "        #result[0] of fractool is sig class\n",
    "        #result[1] of fractool is Hurst coeff\n",
    "        Hurst_actual[i,j] = np.nan_to_num(result[1])\n",
    "        Sig_class_actual[i,j] = result[0]\n",
    "        if ((Sig_class_actual[i,j] != Sig_class_expected[i,j])):\n",
    "            misclassified_total = misclassified_total + 1\n",
    "            Hurst_actual[i,j] = 0\n",
    "            Hurst_expected[i,j] = 1\n",
    "        diff = abs((Hurst_actual[i,j] - Hurst_expected[i,j]))\n",
    "        print(summation)\n",
    "        summation = summation + diff\n",
    "          \n",
    "        #middle third of matrix (fBm signals)\n",
    "    for k in range(int(fgn_section),int(fbm_section)):\n",
    "        Hurst_fbm = random.random()\n",
    "        Hurst_expected[i][k] = Hurst_fbm\n",
    "        Sig_class_expected[i][k] = 2 #fBm class\n",
    "            #generate fBm signal with random Hurst at each element in middle third of matrix\n",
    "        Signal_matrix[i][k] = fbm(n=N3+1, hurst = Hurst_fbm, length=1, method='daviesharte')[1:N3+1]\n",
    "        result = FracTool(Signal_matrix[i,k])\n",
    "            #result[0] of fractool is sig class\n",
    "            #result[1] of fractool is Hurst coeff\n",
    "        Hurst_actual[i,k] = np.nan_to_num(result[1])\n",
    "        Sig_class_actual[i,k] = result[0]\n",
    "        if ((Sig_class_actual[i,k] != Sig_class_expected[i,k])):\n",
    "            misclassified_total = misclassified_total + 1\n",
    "            Hurst_actual[i,k] = 0\n",
    "            Hurst_expected[i,k] = 1\n",
    "        diff = abs((Hurst_actual[i,k] - Hurst_expected[i,k]))\n",
    "        summation = summation + diff\n",
    "                                               \n",
    "        #rightmost third of matrix (random signals)\n",
    "    for l in range(int(fbm_section), N2):\n",
    "        Hurst_rand = 0 #expected Hurst for random signal?\n",
    "        Hurst_expected[i][l] = Hurst_rand\n",
    "        Sig_class_expected[i][l] = 3 #outside model\n",
    "        #generate random array (values between 0 and 1) of length N3 at each element in last third of matrix\n",
    "        Signal_matrix[i][l] = list(np.random.rand(N3))\n",
    "        result = FracTool(Signal_matrix[i,l])\n",
    "        #result[0] of fractool is sig class\n",
    "        #result[1] of fractool is Hurst coeff\n",
    "        Hurst_actual[i,l] = np.nan_to_num(result[1])\n",
    "        Sig_class_actual[i,l] = result[0]\n",
    "        if ((Sig_class_actual[i,l] != Sig_class_expected[i,l])):\n",
    "            misclassified_total = misclassified_total + 1\n",
    "            Hurst_actual[i,l] = 0\n",
    "            Hurst_expected[i,l] = 1\n",
    "        diff = abs((Hurst_actual[i,l] - Hurst_expected[i,l]))\n",
    "        summation = summation + diff\n",
    "     \n",
    "    \n",
    "    #Now find the Hurst value and signal class that FracTool calculates on these known signals\n",
    "    \n",
    "    #Hurst_actual = np.nan_to_num(Hurst_actual)\n",
    "    #print(Hurst_expected)\n",
    "    #print(Hurst_actual)\n",
    "    Misclassified_Rate = misclassified_total/(N1*N2)\n",
    "    MAE_calc = summation/(N1*N2)\n",
    "    print([MAE_calc, Misclassified_Rate])\n",
    "    print(Sig_class_actual)\n",
    "    print(Sig_class_expected)\n",
    "    print(Hurst_actual)\n",
    "    print(Hurst_expected)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    N1 = 1\n",
    "    N2 = 6\n",
    "    N3 = 1000\n",
    "    Hurst_expected = np.zeros((N1,N2))\n",
    "    Sig_class_expected = np.zeros((N1,N2))\n",
    "    Hurst_actual = np.zeros((N1,N2))\n",
    "    Sig_class_actual = np.zeros((N1,N2))\n",
    "    Signal_matrix = np.zeros((N1,N2,N3))\n",
    "    fgn_section = np.floor(N2/3) #end of leftmost third of columns of matrix\n",
    "    fbm_section = fgn_section + fgn_section #end of middle third of columns of matrix\n",
    "    summation = 0\n",
    "    print(summation)\n",
    "    misclassified_total = 0\n",
    "    pool = multiprocessing.Pool(4)\n",
    "    pool.map(MAE, range(1))\n",
    "    pool.close()\n",
    "    pool.join()   \n",
    "    \n",
    "\n",
    "\n",
    "    \n",
    "    \n",
    "#function call \n",
    "#ex:  N1=33, N2=33, N3 = 1024 generates 999 (33x33) signals of length = 1024 time-points"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}