KalmanFilterGyro-main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## data will be read from somewhere, right now I am assuming its just in somewhere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import numpy.random as rando\n",
    "import math\n",
    "import pandas as pd\n",
    "import os\n",
    "import scipy.integrate\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matrix(\"1 1 ; 2 1\").item(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def transition (x_hat_plus):\n",
    "    T=0.01\n",
    "    tau_rx=0.002\n",
    "    tau_ry=0.15\n",
    "    tau_rz=1.0\n",
    "    x1=x_hat_plus.item(0)\n",
    "    x2=x_hat_plus.item(1)\n",
    "    x3=x_hat_plus.item(2)\n",
    "    x4=x_hat_plus.item(3)\n",
    "    x5=x_hat_plus.item(4)\n",
    "    x6=x_hat_plus.item(5)\n",
    "    x7=x_hat_plus.item(6)\n",
    "    n2=math.sqrt(x4**2 + x5**2 + x6**2 + x7**2)\n",
    "    f1=-x1/tau_rx\n",
    "    f2=-x2/tau_ry\n",
    "    f3=-x3/tau_rz\n",
    "    \n",
    "    f4=0.5*(x3*x5 - x2*x6 + x1*x7)/n2\n",
    "    f5=0.5*(-x3*x4 + x1*x6 + x2*x7)/n2\n",
    "    f6=0.5*(x2*x4 - x1*x5 + x3*x7)/n2\n",
    "    f7=0.5*(-x1*x4 - x2*x5 - x3*x6)/n2\n",
    "    \n",
    "    df1_x1=1 - T/tau_rx\n",
    "    df2_x2=1 - T/tau_ry\n",
    "    df3_x3=1 - T/tau_rz\n",
    "    df4_x1=0.5*(x7/n2)\n",
    "    df4_x2=0.5*(-x6/n2)\n",
    "    df4_x3=0.5*(x5/n2)\n",
    "    df4_x4=1 + 0.5*(-f4*x4/(n2**3))\n",
    "    df4_x5=0.5*(x3/n2 - f4*x5/(n2**3))\n",
    "    df4_x6=0.5*(-x2/n2 - f4*x6/(n2**3))\n",
    "    df4_x7=0.5*(x1/n2 - f4*x7/(n2**3))\n",
    "    df5_x1=0.5*(x6/n2)\n",
    "    df5_x2=0.5*(x7/n2)\n",
    "    df5_x3=0.5*(-x4/n2)\n",
    "    df5_x4=0.5*(-x3/n2 - f5*x4/(n2**3))\n",
    "    df5_x5=1 + 0.5*(-f5*x5/(n2**3))\n",
    "    df5_x6=0.5*(x1/n2 - f5*x6/(n2**3))\n",
    "    df5_x7=0.5*(x2/n2 - f5*x7/(n2**3))\n",
    "    df6_x1=0.5*(-x5/n2)\n",
    "    df6_x2=0.5*(x4/n2)\n",
    "    df6_x3=0.5*(x7/n2)\n",
    "    df6_x4=0.5*(x2/n2 - f6*x4/(n2**3))\n",
    "    df6_x5=0.5*(-x1/n2 - f6*x5/(n2**3))\n",
    "    df6_x6=1+.05*(-f6*x6/n2**3)\n",
    "    df6_x7=0.5*(x3/n2 - f6*x7/(n2**3))\n",
    "    \n",
    "    df7_x1=0.5*(-x4/n2)\n",
    "    df7_x2=0.5*(-x5/n2)\n",
    "    df7_x3=0.5*(-x6/n2)\n",
    "    df7_x4=0.5*(-x1/n2 - f7*x4/(n2**3))\n",
    "    df7_x5=0.5*(-x2/n2 - f7*x5/(n2**3))\n",
    "    df7_x6=0.5*(-f7*x7/(n2**3))\n",
    "    df7_x7=1 + 0.5*(-x2/n2 - f7*x6/(n2**3))\n",
    "    \n",
    "    phi=[\n",
    "        [df1_x1 , 0      , 0      , 0      , 0      ,0,0],\n",
    "        [0      , df2_x2 , 0      , 0      , 0      ,0,0],\n",
    "        [0      , 0      , df3_x3 , 0      , 0      ,0,0],\n",
    "        [df4_x1 , df4_x2 , df4_x3 , df4_x4 , df4_x5 ,df4_x6,df4_x7],\n",
    "        [df5_x1,df5_x2,df5_x3,df5_x4,df5_x5,df5_x6,df5_x7],\n",
    "        [df6_x1,df6_x2,df6_x3,df6_x4,df6_x5,df6_x6,df6_x7],\n",
    "        [df7_x1,df7_x2,df7_x3,df7_x4,df7_x5,df7_x6,df7_x7]\n",
    "    ]\n",
    "    return phi\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def projection (t,x):\n",
    "    tau_rx=0.002\n",
    "    tau_ry=0.15\n",
    "    tau_rz=1.0\n",
    "    xprime=[[-x.item(0)/tau_rx],\n",
    "            [-x.item(1)/tau_ry],\n",
    "            [-x.item(2)/tau_rz],\n",
    "            [(x.item(2)*x.item(4)-x.item(1)*x.item(5)+x.item(0)*x.item(6))/(2*math.sqrt(x.item(3)**2+x.item(4)**2+x.item(5)**2+x.item(6)**2))],\n",
    "            [(-x.item(2)*x.item(3)+x.item(0)*x.item(5)+x.item(1)*x.item(6))/(2*math.sqrt(x.item(3)**2+x.item(4)**2+x.item(5)**2+x.item(6)**2))],\n",
    "            [(x.item(1)*x.item(3)-x.item(0)*x.item(4)+x.item(2)*x.item(6))/(2*math.sqrt(x.item(3)**2+x.item(4)**2+x.item(5)**2+x.item(6)**2))],\n",
    "            [(-x.item(0)*x.item(3)-x.item(1)*x.item(4)-x.item(2)*x.item(5))/(2*math.sqrt(x.item(3)**2+x.item(4)**2+x.item(5)**2+x.item(6)**2))]]\n",
    "    return np.matrix(xprime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def rungeKutta(tspan, steps, y0):\n",
    "\n",
    "    [m, n] = np.shape(y0)\n",
    "    dy = np.zeros((m, (steps + 1)))\n",
    "\n",
    "    t  = np.zeros((1, (steps + 1)))\n",
    "\n",
    "    dy[:,[0]] = y  = y0\n",
    "    t[0]  = ti = tspan[0] \n",
    "    h = (tspan[1] - tspan[0]) / float(steps)\n",
    "\n",
    "    # FIRST ORDER RUNGE-KUTTA\n",
    "    for i in range(1, steps + 1): # ITERATE \n",
    "\n",
    "    # FOURTH ORDER RUNGE-KUTTA\n",
    "        \n",
    "        \n",
    "        k1 = projection(ti, y)\n",
    "        k1=k1*h\n",
    "        k2 = projection(ti + h / 2, y + k1 / 2) * h\n",
    "        k3 = projection(ti + h / 2, y + k2 / 2) * h\n",
    "        k4 = projection(ti + h, y + k3) * h\n",
    "\n",
    "        t[0,i]  = ti = tspan[0] + i * h\n",
    "        dy[:,[i]] = y  = y + (k1 + 2 * (k2 + k3) + k4) / 6\n",
    "\n",
    "    return(dy, t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bigdata\n",
      "/home/theurerjohn3\n"
     ]
    }
   ],
   "source": [
    "def read_file(file_name):\n",
    "    file_path = os.path.join(file_name)\n",
    "    print(file_path)\n",
    "    print(os.getcwd())\n",
    "    df = pd.read_csv(file_name,delimiter=\",\",names=[\"accX\",\"accY\",\"accZ\",\"gyroX\",\"gyroY\",\"gyroZ\",\"alt\",\"temp\"],header=None)\n",
    "    return df\n",
    "df = read_file(\"bigdata\")\n",
    "data = df[[\"accX\",\"accY\",\"accZ\",\"gyroX\",\"gyroY\",\"gyroZ\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-55\n"
     ]
    }
   ],
   "source": [
    "print(data.loc[1][\"accX\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def concat_with_zero(A):\n",
    "    zero = np.zeros((3,3))\n",
    "    upper = np.concatenate((A,zero),axis=1)\n",
    "    lower = np.concatenate((zero,A),axis=1)\n",
    "    ret= np.concatenate((upper,lower),axis=0)\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def converge(ye,yb,guess,k):\n",
    "    n_hat = guess\n",
    "    \n",
    "    n_hat = n_hat/math.sqrt( n_hat.transpose() * n_hat )\n",
    "\n",
    "\n",
    "    a = n_hat.item(0)\n",
    "    b = n_hat.item(1)\n",
    "    c = n_hat.item(2)\n",
    "    d = n_hat.item(3)\n",
    "    R_a = np.matrix([[a,b,c],[b,-a,-d],[c,d,-a]])\n",
    "    d_R_a = 2*concat_with_zero(R_a)\n",
    "\n",
    "    R_b = np.matrix([[-b,a,d],[a,b,c],[-d,c,-b]])\n",
    "    d_R_b = 2*concat_with_zero(R_b)\n",
    "\n",
    "    R_c = np.matrix([[-c,-d,a],[d,-c,b],[a,b,c]])\n",
    "    d_R_c = 2*concat_with_zero(R_c)\n",
    "    \n",
    "    R_d = np.matrix([[d,-c,b],[c,d,-a],[-b,a,d]])\n",
    "    d_R_d = 2*concat_with_zero(R_d)\n",
    "    \n",
    "    yb_trans=yb.T\n",
    "    jacobian = np.concatenate(((d_R_a*yb_trans).T,(d_R_b*yb_trans).T,(d_R_c*yb_trans).T,(d_R_d*yb_trans).T),axis=0).T\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "    M_hat = [\n",
    "    [ d*d+a*a-b*b-c*c , 2*(a*b-c*d) , 2*(a*c+b*d) ],\n",
    "    [ 2*(a*b+c*d) , d*d+b*b-a*a-c*c , 2*(c*b-a*d) ],\n",
    "    [ 2*(a*c-b*d) , 2*(b*c+a*d) , d*d+c*c-a*a-b*b ]\n",
    "    ]\n",
    "\n",
    "    R_hat = concat_with_zero(M_hat)\n",
    "    \n",
    "    err = ye - R_hat*(yb.transpose()) # 6x1\n",
    "    #print(n_hat)\n",
    "#     n_hat = 4x1\n",
    "# jacobian = 4x6\n",
    "\n",
    "# 6x4 * 4x6)\n",
    "    n_hat = n_hat - (jacobian.transpose()*jacobian).I*jacobian.transpose()*err\n",
    "\n",
    "    n_hat = n_hat/math.sqrt(n_hat.transpose()*n_hat)\n",
    "\n",
    "    A = (jacobian.transpose()*jacobian).I*jacobian.transpose()*R_hat\n",
    "\n",
    "    cat = n_hat-guess\n",
    "    ssum = 0\n",
    "    for el in cat:\n",
    "        ssum+=el*el\n",
    "    distance = ssum\n",
    "\n",
    "    n = n_hat\n",
    "\n",
    "    if k == 1:\n",
    "        flag = 1\n",
    "    else:\n",
    "        if distance <= .05:\n",
    "            flag = 1\n",
    "        else:\n",
    "            flag = 0\n",
    "    return [n,flag,A]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [2 3]]\n"
     ]
    }
   ],
   "source": [
    "x = np.matrix([1,2])\n",
    "y = np.matrix([2,3])\n",
    "cat = np.concatenate((x,y),axis=0)\n",
    "print(cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sim_data = []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#definitions\n",
    "run_time = 4.50 #simulation time in minutes\n",
    "T = 0.125 #resolution time in seconds\n",
    "samp = 39619 #run_time * 60.0/T # number of samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#time constants\n",
    "tau_rx = 0.002\n",
    "tau_ry = 0.15\n",
    "tau_rz = 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Values of standared devation used in the Q matrix - E[w'*w]\n",
    "\n",
    "stdA =0.00000001\n",
    "stdB = 0.01\n",
    "stdC = 0.30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# process model - noise vector for angular rates\n",
    "# randn('state',sum(100*clock))\n",
    "wrx = np.matrix(rando.normal(0,stdA,math.floor(samp)))\n",
    "wry = np.matrix(rando.normal(0,stdB,math.floor(samp)))\n",
    "wrz = np.matrix(rando.normal(0,stdC,math.floor(samp)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 ..., 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "# process model - noise vector for quaterions - no noise\n",
    "wna = np.matrix([0] * math.floor(samp))\n",
    "wnb = np.matrix([0] * math.floor(samp))\n",
    "wnc = np.matrix([0] * math.floor(samp))\n",
    "wnd = np.matrix([0] * math.floor(samp))\n",
    "print(wnc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "cat = np.matrix([[1,1,1]])\n",
    "print(cat.item(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# system noise vector\n",
    "satan = []\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "\n",
    "for i in range(0,math.floor(samp)):\n",
    "    satan[0].append(wrx.item(0,i))\n",
    "    satan[1].append(wry.item(0,i))\n",
    "    satan[2].append(wrz.item(0,i))\n",
    "    satan[3].append(wna.item(0,i))\n",
    "    satan[4].append(wnb.item(0,i))\n",
    "    satan[5].append(wnc.item(0,i))\n",
    "    satan[6].append(wnd.item(0,i))\n",
    "\n",
    "w = np.matrix(satan)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# measurements - noise vector for angular rates\n",
    "\n",
    "vrx = np.matrix(rando.normal(0,1,math.floor(samp)))\n",
    "vry = np.matrix(rando.normal(0,1,math.floor(samp)))\n",
    "vrz = np.matrix(rando.normal(0,1,math.floor(samp)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.38458244 -1.72655046 -0.93928034 ..., -0.33749079  1.79573195\n",
      "  -0.30310483]]\n"
     ]
    }
   ],
   "source": [
    "# measurements noise vector for angular rates\n",
    "vna = np.matrix(rando.normal(0,1,math.floor(samp)))\n",
    "vnb = np.matrix(rando.normal(0,1,math.floor(samp)))\n",
    "vnc = np.matrix(rando.normal(0,1,math.floor(samp)))\n",
    "vnd = np.matrix(rando.normal(0,1,math.floor(samp)))\n",
    "\n",
    "# measurement noise vector\n",
    "print(vna)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# v = [vrx,vry,vrz,vna,vnb,vnc,vnd]\n",
    "# system noise vector\n",
    "satan = []\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "satan.append([])\n",
    "\n",
    "for i in range(0,math.floor(samp)):\n",
    "    satan[0].append(vrx.item(0,i))\n",
    "    satan[1].append(vry.item(0,i))\n",
    "    satan[2].append(vrz.item(0,i))\n",
    "    satan[3].append(vna.item(0,i))\n",
    "    satan[4].append(vnb.item(0,i))\n",
    "    satan[5].append(vnc.item(0,i))\n",
    "    satan[6].append(vnd.item(0,i))\n",
    "\n",
    "v = np.matrix(satan)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.01]\n",
      " [ 0.01]\n",
      " [ 0.01]\n",
      " [ 0.5 ]\n",
      " [ 0.5 ]\n",
      " [ 0.5 ]\n",
      " [ 0.5 ]]\n"
     ]
    }
   ],
   "source": [
    "#inital conditions\n",
    "x_hat_minus = np.matrix('.01;.01;.01;0.5;0.5;0.5;0.5')\n",
    "print (x_hat_minus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# inital covariance matrix\n",
    "p_minus = np.diag([0.5,0.5,0.5,0.5,0.5,0.5,0.5])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  0.  0.  0.  0.  0.  0.]\n",
      " [ 0.  1.  0.  0.  0.  0.  0.]\n",
      " [ 0.  0.  1.  0.  0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "# Flag = 0 quaternions do not converge\n",
    "\n",
    "R_0 = np.matrix([\n",
    "    [ (0.0000736)*(0.0000736) , 0 , 0 ],\n",
    "    [ 0 , (0.015)*(0.015) , 0 ],\n",
    "    [ 0 , 0 , (0.029)*(0.029) ]\n",
    "])\n",
    "H_1 = np.matrix([[[ 1 , 0 , 0 ] , [ 0 , 1 , 0 ], [ 0 , 0 , 1 ]], [[0,0,0,0],[0,0,0,0],[0,0,0,0]]])\n",
    "H_0 = np.matrix(np.concatenate((np.eye(3), np.zeros((3,4))), axis=1))\n",
    "print(H_0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Flag = 1 quaternions converge\n",
    "R_aux  = np.matrix([\n",
    "    [ (0.110)*(0.110) , 0 , 0 , 0 , 0 , 0 ],\n",
    "    [ 0 , (0.167)*(0.167) , 0 , 0 , 0 , 0 ],\n",
    "    [ 0 , 0 , (0.045)*(0.045) , 0 , 0 , 0 ],\n",
    "    [ 0 , 0 , 0 , (0.030)*(0.030) , 0 , 0 ],\n",
    "    [ 0 , 0 , 0 , 0 , (0.030)*(0.030) , 0 ],\n",
    "    [ 0 , 0 , 0 , 0 , 0 , (0.030)*(0.030) ]\n",
    "])\n",
    "H_1 = np.matrix([\n",
    "            [1,0,0,0,0,0,0],\n",
    "            [0,1,0,0,0,0,0],\n",
    "            [0,0,1,0,0,0,0],\n",
    "            [0,0,0,1,0,0,0],\n",
    "            [0,0,0,0,1,0,0],\n",
    "            [0,0,0,0,0,1,0],\n",
    "            [0,0,0,0,0,0,1]\n",
    "          ])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# process noise covariance matrix\n",
    "Q = np.diag([ stdA*stdA , stdB*stdB , stdC*stdC , 0 , 0 , 0 , 0 ])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.01]\n",
      " [ 0.01]\n",
      " [ 0.01]\n",
      " [ 0.5 ]\n",
      " [ 0.5 ]\n",
      " [ 0.5 ]\n",
      " [ 0.5 ]]\n"
     ]
    }
   ],
   "source": [
    "x_hat_plus_cum = x_hat_minus\n",
    "print(x_hat_plus_cum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Accumulate all the estimates\n",
    "n_acum = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.51550248]\n",
      " [ 0.69603082]\n",
      " [ 0.51538278]\n",
      " [ 0.52640111]\n",
      " [ 0.67067325]\n",
      " [ 0.12696282]\n",
      " [ 0.6640222 ]\n",
      " [ 0.08631035]\n",
      " [ 0.87974726]]\n"
     ]
    }
   ],
   "source": [
    "sim_data = np.matrix([np.random.rand() for _ in range(9)]).T\n",
    "print(sim_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# variable list and size\n",
    "# \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Registry number of times the convergence algorithm diverges\n",
    "flag_cum = []\n",
    "count =0\n",
    "# for k in range(2,math.floor(samp)):\n",
    "for k in range(2,math.floor(samp)):\n",
    "    ye = np.matrix([\n",
    "        [0],\n",
    "        [0],\n",
    "        [-1],\n",
    "        [-0.5],\n",
    "        [0],\n",
    "        [math.sqrt(3)/2]\n",
    "        \n",
    "    ])\n",
    "    \n",
    "    sim_data = np.matrix([np.random.rand() for _ in range(9)]).T\n",
    "\n",
    "    \n",
    "    # step one is read data\n",
    "    g_norm = np.matrix([[data.loc[k][\"accX\"]],[data.loc[k][\"accY\"]],[data.loc[k][\"accZ\"]]])\n",
    "    #print(\"g_norm:\")\n",
    "    #print(g_norm)\n",
    "    h_norm = sim_data[3:6]\n",
    "    #print(\"h_norm:\")\n",
    "    #print(h_norm)\n",
    "    for i in range(0,3):\n",
    "        g_norm[i]= (g_norm[i][0] / 256.0) * 9.8\n",
    "    # take data into g_norm and h_norm\n",
    "    yb = np.concatenate((g_norm, h_norm),axis=0).T\n",
    "    # first guess is the current quaternion\n",
    "    guess = np.matrix(x_hat_minus[3:7])\n",
    "    #n,flag,A = something \n",
    "    # step two converge the quaternions using x_hat(k|k-1)\n",
    "    n,flag,A = converge(ye,yb,guess,k)\n",
    "    flag_cum = [flag_cum, flag]\n",
    "    P_minus = np.diag([ .05 , .05 , .05 , .05 , .05 , .05 , .05 ])\n",
    "    \n",
    "    n_acum = [n_acum , n]\n",
    "    if flag == 1 : # if the quaterinons converge\n",
    "        #get data into z\n",
    "        #print(\"n\")\n",
    "        #print(n)\n",
    "        holder = np.matrix([[data.loc[k][\"gyroX\"]],[data.loc[k][\"gyroY\"]],[data.loc[k][\"gyroZ\"]]])\n",
    "        for i in range(0,3):\n",
    "            holder[i]= (holder[i][0] / 1000.0)\n",
    "        #print(\"holder\")\n",
    "        #print(holder)\n",
    "        z = np.concatenate((holder,n),axis=0)\n",
    "        \n",
    "        top_half = np.concatenate((R_0,np.zeros((3,4))),axis=1)\n",
    "        bottom_half = np.concatenate((np.zeros((4,3)),A*R_aux*A.transpose()),axis=1)\n",
    "        R_1 = np.concatenate((top_half,bottom_half), axis=0)\n",
    "        \n",
    "        K = P_minus * H_1.transpose() * ( H_1*P_minus*H_1.transpose() + R_1).I\n",
    "        x_hat_plus = x_hat_minus + K*(z-H_1*x_hat_minus)\n",
    "        \n",
    "        P_plus = (np.identity(7) - K*H_1)*P_minus\n",
    "    else:\n",
    "        #get data into z\n",
    "        z = np.matrix([[data.loc[k][\"gyroX\"]],[data.loc[k][\"gyroY\"]],[data.loc[k][\"gyroZ\"]]])\n",
    "        for i in range(0,3):\n",
    "            z[i]= (z[i][0] / 1000.0)\n",
    "        K = P_minus * H_0.transpose() * ( H_0*P_minus*H_0.transpose() + R_0).I\n",
    "        x_hat_plus = x_hat_minus + K*(z-H_0*x_hat_minus)\n",
    "        \n",
    "        P_plus = (np.identity(7) - K*H_0)*P_minus\n",
    "        \n",
    "        count+1\n",
    "    #print(k)\n",
    "    #print(x_hat_plus[3:])\n",
    "    \n",
    "    x_hat_plus_cum = np.concatenate((x_hat_plus_cum,x_hat_plus),axis=1)\n",
    "    phi = np.matrix(transition(x_hat_plus))\n",
    "    P_minus = phi*P_plus*phi.transpose()+Q\n",
    "    \n",
    "    x_aux,ti = rungeKutta([0,T],1,x_hat_plus)\n",
    "    #ti,x_aux = ode45('projection',[0,T],x_hat_plus)\n",
    "    \n",
    "    #print(x_hat_minus)\n",
    "    carryover = []\n",
    "    for i in range(0,7):\n",
    "        carryover.append([])\n",
    "        carryover[i].append(x_aux.item(i,1))\n",
    "    x_hat_minus = np.matrix(carryover)\n",
    "    #x_hat_minus = x_aux[1]\n",
    "    \n",
    "\n",
    "\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[  8.66713507e-08,   0.00000000e+00,   0.00000000e+00,\n",
       "          -8.62984796e-09,  -5.81905008e-09,  -2.83933006e-10,\n",
       "          -2.99291824e-09],\n",
       "        [  0.00000000e+00,   2.95121951e-04,   0.00000000e+00,\n",
       "          -5.61443264e-05,   8.32639337e-05,  -2.88767713e-05,\n",
       "           2.73948964e-06],\n",
       "        [  0.00000000e+00,   0.00000000e+00,   9.08106293e-02,\n",
       "          -1.07296960e-05,   1.13100986e-04,   3.26117934e-04,\n",
       "          -2.19899191e-04]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H_0*P_minus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.matrixlib.defmatrix.matrix"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(P_minus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1.00000000e-02   1.08339188e-09   7.00703257e-11 ...,   0.00000000e+00\n",
      "    0.00000000e+00   0.00000000e+00]\n",
      " [  1.00000000e-02   4.47984072e-05   8.78082084e-08 ...,   0.00000000e+00\n",
      "    0.00000000e+00   0.00000000e+00]\n",
      " [  1.00000000e-02   1.65417675e-04   2.41477758e-06 ...,   0.00000000e+00\n",
      "    0.00000000e+00   0.00000000e+00]\n",
      " ..., \n",
      " [  5.00000000e-01   4.13300627e-01   3.26902239e-01 ...,  -1.70801632e+03\n",
      "   -1.70801632e+03  -1.70801632e+03]\n",
      " [  5.00000000e-01   3.78633716e-01   2.61982191e-01 ...,   3.50048507e+04\n",
      "    3.50048507e+04   3.50048507e+04]\n",
      " [  5.00000000e-01   5.54095562e-01   5.87170534e-01 ...,   5.19133767e+04\n",
      "    5.19133767e+04   5.19133767e+04]]\n"
     ]
    }
   ],
   "source": [
    "print(x_hat_plus_cum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39618\n",
      "39618\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAD8CAYAAACPWyg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2206fa7c88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plottyA = []\n",
    "plottyB = []\n",
    "plottyC = []\n",
    "plottyD = []\n",
    "\n",
    "y,cruel =x_hat_plus_cum.shape\n",
    "for i in range(0,cruel):\n",
    "    plottyA.append(x_hat_plus_cum.item(3,i))\n",
    "    plottyB.append(x_hat_plus_cum.item(4,i))\n",
    "    plottyC.append(x_hat_plus_cum.item(5,i))\n",
    "    plottyD.append(x_hat_plus_cum.item(6,i))\n",
    "    \n",
    "print(len(plottyA))\n",
    "danger = range(0,cruel)\n",
    "print(len(danger))\n",
    "\n",
    "plt.scatter(danger,plottyA)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAD8CAYAAACPWyg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2207006ba8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(danger,plottyB)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAD8CAYAAACCRVh7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2202ff2198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(danger,plottyC)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAD8CAYAAACPWyg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAGvpJREFUeJzt3X9wXeV95/H3B9kGhQAyoHpBNmsn8ZAxYYtBC2bIdBLY\nYAMpVhOSQtvFk/XgmQVm0mWXxt50FpLAhNTThTIldL3Fi2lpjMsP4wYS1QU62W3HgFwTjKEuioFi\n8cMutoEWFRv7u3/cR+Zavj90pCvdR/LnNXPnnvM9zz3nq3MtfX3O85xzFBGYmZkVcVSzEzAzs/HH\nxcPMzApz8TAzs8JcPMzMrDAXDzMzK8zFw8zMCnPxMDOzwlw8zMysMBcPMzMrbFKzExgtJ598csyc\nObPZaZiZjSsbN278p4hor9duwhaPmTNn0tPT0+w0zMzGFUmvDaWdT1uZmVlhLh5mZlaYi4eZmRXm\n4mFmZoW5eJiZWWETdrSVmdl4NnPpYyNex7TjpvD0t7/UgGwO5yMPM7PMNKJwALz9/l7Ou3V9Q9Y1\nmIuHmdkE9vb7e0dlvS4eZmZWmIuHmZkV1pDiIelVSZslPSepJ8VOlLRe0svpfWqKS9KdknolPS/p\n7LL1LErtX5a0qCx+Tlp/b/qsGpG3mdlEN+24KaOy3kYeeXwxIs6KiM40vxR4IiJmA0+keYBLgNnp\ntQS4G0rFBrgJOA84F7hpoOCkNteUfW5BA/M2M8vKHb9+VkPWM5qjrUZzqO5C4AtpehXw18C3Uvy+\niAhgg6Q2SaektusjYheApPXAAkl/DRwfERtS/D6gC/jJKOZuZtY0XXM7AFjevZU39vRzalsrN84/\n/WA8B40qHgH8paQA/ldErACmRcSbaflbwLQ03QG8XvbZ7SlWK769QtzMbMLqmtuRVbEYrFHF4/MR\n0Sfpl4D1kv6+fGFERCoso0rSEkqnwjjttNNGe3NmZqNm7aa+rI88GtLnERF96X0H8AilPou30+ko\n0vuO1LwPmFH28ekpVis+vUK8Uh4rIqIzIjrb2+s+y8TMLEtrN/Wx7OHN9O3pJ4C+Pf0se3gzazdV\n/NPXFCMuHpKOlXTcwDRwMfACsA4YGDG1CHg0Ta8Drk6jruYB76bTW93AxZKmpo7yi4HutOw9SfPS\nKKury9ZlZjbhLO/eSv++/YfE+vftZ3n31iZldLhGnLaaBjySRs9OAv4sIn4q6VlgjaTFwGvA11P7\nx4FLgV7gA+AbABGxS9L3gGdTu+8OdJ4D1wL3Aq2UOsrdWW5mE9Ybe/oLxZthxMUjIrYBv1wh/g5w\nUYV4ANdVWddKYGWFeA/wuZHmamY2Hpza1kpfhUJxaltrE7KpzFeYm5ll5oufrdxnWy3eDC4eZmaZ\neez5NwvFm8HFw8wsM7s/2Fco3gwuHmZmVpiLh5mZFebiYWaWmbbWyYXizeDiYWaWmZsvP4PJRx36\n5InJR4mbLz+jSRkdbjTvqmtmZsMwHu6q6yMPMzMrzEceZmaZGbgx4sD9rQZujAhkc/ThIw8zs8yM\nhxsjuniYmWVmPNwY0cXDzCwzJ1QZklst3gwuHmZmmZGKxZvBxcPMLDO+t5WZmRVW7QAjowMPFw8z\ns9xEwXgzuHiYmVlhLh5mZuPE1E94tJWZmVUwc+ljVZfd9Kv53BjRxcPMLBOfWVa9cOSmYcVDUouk\nTZJ+nOZnSXpaUq+kByRNSfGj03xvWj6zbB3LUnyrpPll8QUp1itpaaNyNjPLyUd1esQn6u1Jvgm8\nVDb/A+D2iPgMsBtYnOKLgd0pfntqh6Q5wJXAGcAC4IepILUAdwGXAHOAq1JbM7MjyoS7PYmk6cBl\nwB+neQEXAg+mJquArjS9MM2Tll+U2i8EVkfEhxHxCtALnJtevRGxLSL2AqtTWzOzI8qpba3NTuGg\nRh153AH8DnAgzZ8E7ImIj9L8dmDgPsIdwOsAafm7qf3B+KDPVIsfRtISST2Senbu3DnSn8nMbExN\nqnMV4I3zTx+bRIZgxMVD0peBHRGxsQH5jEhErIiIzojobG9vb3Y6ZmaF9H7/sprLc3mWBzTmYVAX\nAJdLuhQ4Bjge+AOgTdKkdHQxHehL7fuAGcB2SZOAE4B3yuIDyj9TLW5mZk0w4iOPiFgWEdMjYial\nDu8nI+I3gaeAK1KzRcCjaXpdmictfzIiIsWvTKOxZgGzgWeAZ4HZafTWlLSNdSPN28zMhm80r/P4\nFnCDpF5KfRr3pPg9wEkpfgOwFCAitgBrgBeBnwLXRcT+dORyPdBNaTTXmtTWzOyIsnZTPiddVPpP\n/8TT2dkZPT09zU7DzKyQWleYd7S18jdLLxzV7UvaGBGd9dr5CnMzs3Fiwl3nYWZmo28iXudhZmaj\nbEJd52FmZo1Rr0M8p+s8XDzMzDKR040P63HxMDPLRK0O8cmZ/bXOLB0zsyNXrQ7xSS15/bnOKxsz\nsyNYrQ7x/n0Hqi5rBhcPM7NM5NQhXo+Lh5mZFebiYWZmhbl4mJlZYS4eZmaZyOmuufW4eJiZZaLW\nRYLHTmkZw0zqc/EwM8tErYsEb/21M8cwk/pcPMzMMlHtIsG21snZDeN18TAzy8SN80+ndfKhp6da\nJ7dw8+VnNCmj6lw8zMwy0TW3g+9/5UzaWicfjB2T202tkjyzMjM7QvW8tot3+/cdnN/9wT6WPbw5\nu5FYLh5mZplYu6mP+zf8IzEo3r9vf3a3ax9x8ZB0jKRnJP1c0hZJ30nxWZKeltQr6QFJU1L86DTf\nm5bPLFvXshTfKml+WXxBivVKWjrSnM3McrS8e+thhWNATs8vh8YceXwIXBgRvwycBSyQNA/4AXB7\nRHwG2A0sTu0XA7tT/PbUDklzgCuBM4AFwA8ltUhqAe4CLgHmAFeltmZmE0qtApHT88uhAcUjSv45\nzU5OrwAuBB5M8VVAV5pemOZJyy+SpBRfHREfRsQrQC9wbnr1RsS2iNgLrE5tzcwmlGoFQuT1/HJo\nUJ9HOkJ4DtgBrAd+AeyJiI9Sk+3AwCDlDuB1gLT8XeCk8vigz1SLm5lNKJWG6gIcd3TLxLzOIyL2\nR8RZwHRKRwqfbcR6i5K0RFKPpJ6dO3c2IwUzs2HrmtvB8cccXjze+3A/5926vgkZVdfQ0VYRsQd4\nCjgfaJM0KS2aDgyMM+sDZgCk5ScA75THB32mWrzS9ldERGdEdLa3tzfkZzIzG0tvv7+3ajyn4bqN\nGG3VLqktTbcCXwJeolRErkjNFgGPpul1aZ60/MmIiBS/Mo3GmgXMBp4BngVmp9FbUyh1qq8bad5m\nZuNNTsN1J9VvUtcpwKo0KuooYE1E/FjSi8BqSbcAm4B7Uvt7gD+R1AvsolQMiIgtktYALwIfAddF\nxH4ASdcD3UALsDIitjQgbzOzcSWn4bojLh4R8Twwt0J8G6X+j8HxfwW+VmVdtwK3Vog/Djw+0lzN\nzMaznIbr+gpzM7NM1OvTyGm4rouHmVkm6vVp5DRc18XDzCwTOfVp1OPiYWaWiZz6NOpx8TAzy8QX\nP1v9+rTyZ3zkwMXDzCwTT/199TtjSGOYyBC4eJiZZaJWn8fuD/ZVXdYMLh5mZplwn4eZmRVW7zqO\n3127eYwyqc/Fw8wsE/Wu4/jTDf84RpnU5+JhZpaRqZ/Ia1RVNS4eZmYZuelXz2h2CkPi4mFmZoW5\neJiZZeTmdePjiRMuHmZmGdnTn9f1HNW4eJiZWWEuHmZmGTkqs9uQVOPiYWaWkQPR7AyGxsXDzCwj\nx05paXYKQ+LiYWaWid9du5l/2bu/2WkMyYiLh6QZkp6S9KKkLZK+meInSlov6eX0PjXFJelOSb2S\nnpd0dtm6FqX2L0taVBY/R9Lm9Jk7pdxuTmxmNnI/evr1mstz6g9pxJHHR8B/jYg5wDzgOklzgKXA\nExExG3gizQNcAsxOryXA3VAqNsBNwHnAucBNAwUntbmm7HMLGpC3mVlW9kftDo+c+kNGXDwi4s2I\n+Ls0/T7wEtABLARWpWargK40vRC4L0o2AG2STgHmA+sjYldE7AbWAwvSsuMjYkNEBHBf2brMzCaM\nljonVeotH0sN7fOQNBOYCzwNTIuIN9Oit4BpaboDKD82255iteLbK8TNzCaUq86bUXN5vSOTsdSw\n4iHpk8BDwG9HxHvly9IRw6j/1JKWSOqR1LNzZ/XHOZqZ5eiWrjNrLp9wRx6SJlMqHPdHxMMp/HY6\n5UR635HifUB5eZ2eYrXi0yvEDxMRKyKiMyI629urP0jezCxHazdV/NN20IQ68kgjn+4BXoqI/1m2\naB0wMGJqEfBoWfzqNOpqHvBuOr3VDVwsaWrqKL8Y6E7L3pM0L23r6rJ1mZlNGN/5i9o3RezI6DG1\nkxqwjguA/whslvRciv134DZgjaTFwGvA19Oyx4FLgV7gA+AbABGxS9L3gGdTu+9GxK40fS1wL9AK\n/CS9zMwmlN0f1L4pYr3H1I6lERePiPh/QLUTcRdVaB/AdVXWtRJYWSHeA3xuBGmamVkD+QpzM7Nx\nYnn31mancJCLh5nZONG3p7/ZKRzk4mFmNk5MuKG6ZmY2+ibUUF0zMxsbOQ3VdfEwMxsHjlJeQ3Vd\nPMzMxoEDAV1z87mtn4uHmZkV5uJhZpaJqZ+Y3OwUhszFw8wsE3vq3J6k3o0Tx5KLh5lZJk6tM5rK\nV5ibmdlhZp5Uu3i84SvMzcxssA3bdtdcfkJrPn0iLh5mZpmodwX5vv0HxiiT+lw8zMzGiX/Zu7/Z\nKRzk4mFmZoW5eJiZWWEuHmZmVpiLh5mZFebiYWaWiZwe9lSPi4eZWSZyethTPQ0pHpJWStoh6YWy\n2ImS1kt6Ob1PTXFJulNSr6TnJZ1d9plFqf3LkhaVxc+RtDl95k5pHJVnM7MhyulhT/U06sjjXmDB\noNhS4ImImA08keYBLgFmp9cS4G4oFRvgJuA84FzgpoGCk9pcU/a5wdsyMxv3bpx/Oq2TW5qdxpA0\npHhExM+AXYPCC4FVaXoV0FUWvy9KNgBtkk4B5gPrI2JXROwG1gML0rLjI2JDRARwX9m6zMwmjK65\nHXz1nOoPfJqcUUfDaKYyLSLeTNNvAdPSdAfwelm77SlWK769QtzMbEJZu6mPhzZWv+36J485wu5t\nlY4YRr0nSNISST2Senbu3DnamzMza6jl3Vvp31f9FiT1nvcxlkazeLydTjmR3nekeB8wo6zd9BSr\nFZ9eIX6YiFgREZ0R0dne3t6QH8LMbKz01bnler3nfYyl0Swe64CBEVOLgEfL4lenUVfzgHfT6a1u\n4GJJU1NH+cVAd1r2nqR5aZTV1WXrMjObMGpd59E6uYUb558+htnUNqkRK5H0I+ALwMmStlMaNXUb\nsEbSYuA14Oup+ePApUAv8AHwDYCI2CXpe8Czqd13I2KgE/5aSiO6WoGfpJeZ2YRS6zqP73/lTLrm\n5tPd25DiERFXVVl0UYW2AVxXZT0rgZUV4j3A50aSo5lZ7jraWiueuupoa82qcICvMDczy0al6zxy\nO101oCFHHmZmNnIDRxfLu7fyxp5+Tm1r5cb5p2d31AEuHmZmWema25FlsRjMp63MzKwwH3mYmWVk\n7aY+n7YyM7OhW7upj2UPbz54lXnfnn6WPbwZILsC4tNWZmaZqHR7kv59+1nevbVJGVXn4mFmlolq\ntyepd9uSZnDxMDPLRLXbk+T4eFoXDzOzTFS7PUmOj6d18TAzy0S1x9Dm+HhaFw8zs0zcOP90Jrcc\neopqcouyvD2Ji4eZWU4Gn6HK74wV4OJhZpaN5d1b2Xfg0Gqx70B4qK6ZmVX3RpUhudXizeTiYWaW\niWqPmc3p8bMDXDzMzDIxnp7n4eJhZpaJrrkdfPWcjoMXBbZIfPWcPG/R7uJhZpaJtZv6eGhj38GL\nAvdH8NDGPtZu6mtyZodz8TAzy4RvjDgKJC2QtFVSr6Slzc7HzKzRxtONEcfF8zwktQB3AV8CtgPP\nSloXES82cjszlz7WyNWZmU1Y4+XI41ygNyK2RcReYDWwsJEbcOEwMxu68VI8OoDXy+a3p5iZmTXB\neCkeQyJpiaQeST07d+5sdjpmZhPWeCkefcCMsvnpKXaIiFgREZ0R0dne3j5myZmZHWnGS/F4Fpgt\naZakKcCVwLom52RmdsQaF8UjIj4Crge6gZeANRGxpZHbePW2yxq5OjOzhrnj189qdgqHUWT4eMNG\n6OzsjJ6enmanYWY2ZBfc9mTFazo62lr5m6UXjkkOkjZGRGe9duPiyMPM7EjgW7KbmVlhviW7mZkV\nNvOkykWiWryZXDzMzDLxt7/YVSjeTC4eZmaZqDZ8KcdhTS4eZmZWmIuHmZkV5uJhZmaFuXiYmVlh\nLh5mZlaYi4eZmRXm4mFmZoW5eJiZWWEuHmZmVpiLh5mZFebiYWZmhbl4mJlZYS4eZmaZmP1LxxaK\nN5OLh5lZJrbt/KBQvJlcPMzMMrE/Kt98vVq8mVw8zMwy0SIVijfTiIqHpK9J2iLpgKTOQcuWSeqV\ntFXS/LL4ghTrlbS0LD5L0tMp/oCkKSl+dJrvTctnjiRnM7NcXXXejELxZhrpkccLwFeAn5UHJc0B\nrgTOABYAP5TUIqkFuAu4BJgDXJXaAvwAuD0iPgPsBhan+GJgd4rfntqZmU04t3SdyW/NO+3gkUaL\nxG/NO41bus5scmaHmzSSD0fESwA6/JBqIbA6Ij4EXpHUC5yblvVGxLb0udXAQkkvARcCv5HarAJu\nBu5O67o5xR8E/lCSIjI8CWhmNkK3dJ2ZZbEYbLT6PDqA18vmt6dYtfhJwJ6I+GhQ/JB1peXvpvaH\nkbREUo+knp07dzboRzEzs8HqHnlI+ivg31RY9O2IeLTxKQ1fRKwAVgB0dnb6yMTMbJTULR4R8R+G\nsd4+oLyHZ3qKUSX+DtAmaVI6uihvP7Cu7ZImASek9mZmE87aTX0s797KG3v6ObWtlRvnn07X3I76\nHxxjo3Xaah1wZRopNQuYDTwDPAvMTiOrplDqVF+X+i+eAq5In18EPFq2rkVp+grgSfd3mNlEtHZT\nHzc88Bx9e/oJoG9PPzc88BxrN/XV/exYG+lQ3V+TtB04H3hMUjdARGwB1gAvAj8FrouI/emo4nqg\nG3gJWJPaAnwLuCF1rp8E3JPi9wAnpfgNwMHhvWZmE8myh5/nwKDYgRTPzUhHWz0CPFJl2a3ArRXi\njwOPV4hv4+MRWeXxfwW+NpI8zczGg/59g0tH7Xgz+QpzMzMrzMXDzMwKc/EwM7PCXDzMzDJxVJX7\nH1aLN5OLh5lZJn7jvNMKxZvJxcPMLBPrt7xVKN5MLh5mZpl4+/29heLN5OJhZmaFuXiYmVlhLh5m\nZlaYi4eZmRXm4mFmZoW5eJiZZeKCT59YKN5MLh5mZpm4/5rzDysUF3z6RO6/5vwmZVTdiG7JbmZm\njZVjoajERx5mZlaYi4eZmRXm4mFmZoW5eJiZWWEuHmZmVpgiotk5jApJO4HXhvnxk4F/amA6jZRr\nbs6ruFxzyzUvyDe3iZTXv42I9nqNJmzxGAlJPRHR2ew8Ksk1N+dVXK655ZoX5JvbkZiXT1uZmVlh\nLh5mZlaYi0dlK5qdQA255ua8iss1t1zzgnxzO+Lycp+HmZkV5iMPMzMrzMVjEEkLJG2V1Ctp6Rht\n81VJmyU9J6knxU6UtF7Sy+l9aopL0p0pv+clnV22nkWp/cuSFg0jj5WSdkh6oSzWsDwknZN+zt70\nWY0wt5sl9aX99pykS8uWLUvb2Sppflm84vcraZakp1P8AUlThpjXDElPSXpR0hZJ38xhv9XIK4d9\ndoykZyT9POX2nVrrk3R0mu9Ny2cON+dh5nWvpFfK9tlZKT7WvwMtkjZJ+nEO+4uI8Cu9gBbgF8Cn\ngCnAz4E5Y7DdV4GTB8V+D1iappcCP0jTlwI/AQTMA55O8ROBbel9apqeWjCPXwHOBl4YjTyAZ1Jb\npc9eMsLcbgb+W4W2c9J3dzQwK32nLbW+X2ANcGWa/iPgPw8xr1OAs9P0ccA/pO03db/VyCuHfSbg\nk2l6MvB0+vkqrg+4FvijNH0l8MBwcx5mXvcCV1RoP9a/AzcAfwb8uNb+H6v95SOPQ50L9EbEtojY\nC6wGFjYpl4XAqjS9Cugqi98XJRuANkmnAPOB9RGxKyJ2A+uBBUU2GBE/A3aNRh5p2fERsSFK/5Lv\nK1vXcHOrZiGwOiI+jIhXgF5K323F7zf97+9C4MEKP2e9vN6MiL9L0+8DLwEdNHm/1cirmrHcZxER\n/5xmJ6dX1Fhf+b58ELgobb9QziPIq5ox+x2QNB24DPjjNF9r/4/J/nLxOFQH8HrZ/HZq/8I1SgB/\nKWmjpCUpNi0i3kzTbwHT6uQ4Wrk3Ko+ONN3o/K5PpwxWKp0aGkZuJwF7IuKjkeSWTg/MpfQ/1mz2\n26C8IIN9lk7BPAfsoPTH9Rc11ncwh7T83bT9hv8uDM4rIgb22a1pn90u6ejBeQ1x+yP5Lu8Afgc4\nkOZr7f8x2V8uHnn4fEScDVwCXCfpV8oXpv+lNH1YXC55lLkb+DRwFvAm8PvNSkTSJ4GHgN+OiPfK\nlzVzv1XIK4t9FhH7I+IsYDql//l+thl5DDY4L0mfA5ZRyu/fUzoV9a2xzEnSl4EdEbFxLLdbj4vH\nofqAGWXz01NsVEVEX3rfATxC6Zfp7XSYS3rfUSfH0cq9UXn0pemG5RcRb6df9gPA/6a034aT2zuU\nTjlMGhQfEkmTKf2Bvj8iHk7hpu+3Snnlss8GRMQe4Cng/BrrO5hDWn5C2v6o/S6U5bUgnQKMiPgQ\n+D8Mf58N97u8ALhc0quUTildCPwBzd5f9TpFjqQXpcfybqPUmTTQcXTGKG/zWOC4sum/pdRXsZxD\nO1x/L01fxqGddM/Ex510r1DqoJuapk8cRj4zObRTumF5cHhn4aUjzO2Usun/Qul8LsAZHNoxuI1S\np2DV7xf4cw7tfLx2iDmJ0rnrOwbFm7rfauSVwz5rB9rSdCvwf4EvV1sfcB2HdgCvGW7Ow8zrlLJ9\negdwWxN/B77Axx3mzd1fRf+4TPQXpREU/0DpHOy3x2B7n0pf1s+BLQPbpHSO8gngZeCvyv7xCbgr\n5bcZ6Cxb13+i1AnWC3xjGLn8iNKpjH2UznsubmQeQCfwQvrMH5IuUh1Bbn+Stv08sI5D/zB+O21n\nK2UjWqp9v+l7eCbl/OfA0UPM6/OUTkk9DzyXXpc2e7/VyCuHffbvgE0phxeA/1FrfcAxab43Lf/U\ncHMeZl5Ppn32AvCnfDwia0x/B9Lnv8DHxaOp+8tXmJuZWWHu8zAzs8JcPMzMrDAXDzMzK8zFw8zM\nCnPxMDOzwlw8zMysMBcPMzMrzMXDzMwK+/+OYrquL48AiQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2202f7e5f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(danger,plottyD)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "int x = 5;\n",
    "x = \"thingy\"\n",
    "String x = \"thingy\";\n",
    "Cstrings "
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}