scidart_test_reference.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FFT tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.fftpack import fft, ifft\n",
    "print(fft([1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0]))\n",
    "print(ifft([4.+0.j, 1.-2.41421356j, 0.-0.j, 1.-0.41421356j, 0.+0.j, 1.+0.41421356j, 0.+0.j, 1.+2.41421356j]))\n",
    "\n",
    "print(abs(ifft([4.+0.j, 1.-2.41421356j, 0.-0.j, 1.-0.41421356j, 0.+0.j, 1.+0.41421356j, 0.+0.j, 1.+2.41421356j])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "n = np.linspace(1.2,3)\n",
    "print(len(n))\n",
    "n\n",
    "\n",
    "n = np.linspace(1.2,3, endpoint=False)\n",
    "print(len(n))\n",
    "n\n",
    "\n",
    "n = np.linspace(1.2,3, num=3)\n",
    "n\n",
    "\n",
    "n = np.linspace(1.2,3, num=3, endpoint=False)\n",
    "n\n",
    "\n",
    "np.zeros(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Windowtests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "w = signal.hann(10)\n",
    "print(w)\n",
    "print(len(w))\n",
    "\n",
    "w2 = signal.hann(10, False)\n",
    "print(w2)\n",
    "print(len(w2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = [1,2,3]\n",
    "print(w[:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "w = signal.hamming(10)\n",
    "print(w)\n",
    "print(len(w))\n",
    "\n",
    "w2 = signal.hamming(10, False)\n",
    "print(w2)\n",
    "print(len(w2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "w = signal.blackman(10)\n",
    "print(w)\n",
    "print(len(w))\n",
    "\n",
    "w2 = signal.blackman(10, False)\n",
    "print(w2)\n",
    "print(len(w2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "w = signal.blackmanharris(10)\n",
    "print(w)\n",
    "print(len(w))\n",
    "\n",
    "w2 = signal.blackmanharris(10, False)\n",
    "print(w2)\n",
    "print(len(w2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "w = signal.flattop(10)\n",
    "print(w)\n",
    "print(len(w))\n",
    "\n",
    "w2 = signal.flattop(10, False)\n",
    "print(w2)\n",
    "print(len(w2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "w = signal.hamming(10)\n",
    "print(w)\n",
    "print(len(w))\n",
    "\n",
    "w2 = signal.hamming(10, False)\n",
    "print(w2)\n",
    "print(len(w2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "w = signal.nuttall(10)\n",
    "print(w)\n",
    "print(len(w))\n",
    "\n",
    "w2 = signal.nuttall(10, False)\n",
    "print(w2)\n",
    "print(len(w2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.core.numeric import (\n",
    "    absolute, asanyarray, arange, zeros, greater_equal, multiply, ones,\n",
    "    asarray, where, int8, int16, int32, int64, empty, promote_types, diagonal,\n",
    "    nonzero\n",
    "    )\n",
    "\n",
    "x = asarray([99,99,99])\n",
    "N = len(x)\n",
    "v = empty((len(x), N), dtype=promote_types(x.dtype, int))\n",
    "\n",
    "print(v)\n",
    "\n",
    "tmp = v[:, ::-1]\n",
    "\n",
    "tmp[:, 1:] = x[:, None]\n",
    "\n",
    "print(tmp)\n",
    "print(x[:, None])\n",
    "\n",
    "multiply.accumulate(tmp[:, 1:], out=tmp[:, 1:], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.lib.twodim_base import vander\n",
    "print(vander([2,4,8], increasing = True))\n",
    "print(vander([2,4,8]))\n",
    "\n",
    "print(vander([2,4,8], N = 2, increasing = True))\n",
    "print(vander([2,4,8], N = 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.lib.twodim_base import vander\n",
    "import numpy as np\n",
    "v = vander([2,4,8])\n",
    "w = asarray([2,2,2])\n",
    "print(v)\n",
    "print(w[:, np.newaxis])\n",
    "v * w[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy.core.numeric as NX\n",
    "import numpy as np\n",
    "\n",
    "lhs = vander([2,4,8])\n",
    "print(lhs)\n",
    "scale = NX.sqrt((lhs*lhs).sum(axis=0))\n",
    "print(scale)\n",
    "res = lhs / scale\n",
    "print(res)\n",
    "\n",
    "# a = np.array([[1,2,3],[1,2,3],[1,2,3]])\n",
    "# b = np.array([[1],[2],[3]])\n",
    "\n",
    "# print(a/b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.06052275 -0.6022239  -0.79602975]\n",
      " [-0.24209101 -0.76482436  0.59702231]\n",
      " [-0.96836405  0.22884508 -0.09950372]]\n",
      "[[-66.09084657  -8.83632198  -1.27097782]\n",
      " [  0.          -2.43298457  -1.13820318]\n",
      " [  0.           0.          -0.29851116]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([[4, 2, 1], [16, 4, 1], [64, 8, 1]])\n",
    "# a = np.array(((\n",
    "#     (12, -51,   4),\n",
    "#     ( 6, 167, -68),\n",
    "#     (-4,  24, -41),\n",
    "# )))\n",
    "\n",
    "q, r = np.linalg.qr(a)\n",
    "print(q)\n",
    "print(r)\n",
    "\n",
    "# q:\n",
    "#  [[-0.857143  0.394286  0.331429]\n",
    "#  [-0.428571 -0.902857 -0.034286]\n",
    "#  [ 0.285714 -0.171429  0.942857]]\n",
    "# r:\n",
    "#  [[ -14.  -21.   14.]\n",
    "#  [   0. -175.   70.]\n",
    "#  [   0.    0.  -35.]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.linalg as la\n",
    "\n",
    "a = np.array([[4, 2, 1], [16, 4, 1], [64, 8, 1]])\n",
    "\n",
    "p, l, u = la.lu(a)\n",
    "print(l)\n",
    "print(u)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[3,1], [1,2]])\n",
    "b = np.array([9,8])\n",
    "x = np.linalg.solve(a, b)\n",
    "print(x)\n",
    "\n",
    "a = np.array([[1,2,3], [4,5,6], [7,8,10]])\n",
    "b = np.array([9,4,6])\n",
    "x = np.linalg.solve(a, b)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1,2,3], [4,5,6], [7,8,10]])\n",
    "x = np.linalg.inv(a)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1,2,3], [4,5,6], [7,8,10]])\n",
    "x = np.matrix.transpose(a)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "x = np.array([0.0, 1.0, 2.0, 3.0,  4.0,  5.0])\n",
    "y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])\n",
    "z = np.polyfit(x, y, 3)\n",
    "print(z)\n",
    "\n",
    "x = np.array([0.0, 1.0,  2.0,  3.0,  4.0,  5.0,   6.0,   7.0,   8.0,   9.0,  10.0]);\n",
    "y = np.array([1.0, 6.0, 17.0, 34.0, 57.0, 86.0, 121.0, 162.0, 209.0, 262.0, 321.0]);\n",
    "z = np.polyfit(x, y, 3)\n",
    "print(z)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9.70248526e-19  4.88092689e-15  1.64391055e-11 -4.49364465e-08\n",
      " -1.72866393e-03 -2.43883188e+01]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/polotto/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3457: RankWarning: Polyfit may be poorly conditioned\n",
      "  exec(code_obj, self.user_global_ns, self.user_ns)\n"
     ]
    }
   ],
   "source": [
    "x = np.array([7614, 7614, 7614, 7980, 7980, 7980, 7980])\n",
    "y = np.array([1, 4, 20, 25, 25, 20, 4])\n",
    "z = np.polyfit(x, y, 5)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([[4, 2, 1], [16, 4, 1], [64, 8, 1]])\n",
    "u, s, vh = np.linalg.svd(a, full_matrices=True)\n",
    "\n",
    "print(u)\n",
    "print(s)\n",
    "print(vh)\n",
    "\n",
    "a = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])\n",
    "u, s, vh = np.linalg.svd(a, full_matrices=True)\n",
    "print()\n",
    "print(u)\n",
    "print(s)\n",
    "print(vh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "y = np.array([9,8,7,6])\n",
    "x = np.array([1,3,1,1])\n",
    "nd = y.ndim\n",
    "print(y.shape)\n",
    "print(len(y.shape))\n",
    "\n",
    "axis = -1\n",
    "dx = 1\n",
    "\n",
    "# d = dx\n",
    "d = np.diff(x)\n",
    "print(d)\n",
    "\n",
    "slice1 = [slice(None)]*nd\n",
    "slice2 = [slice(None)]*nd\n",
    "slice1[axis] = slice(1, None)\n",
    "slice2[axis] = slice(None, -1)\n",
    "\n",
    "print(slice1)\n",
    "print(slice2)\n",
    "\n",
    "print(tuple(slice1))\n",
    "print(tuple(slice2))\n",
    "\n",
    "print(y[tuple(slice1)])\n",
    "print(y[tuple(slice2)])\n",
    "\n",
    "print(np.trapz(y, x=x))\n",
    "\n",
    "ret = (d * (y[tuple(slice1)] + y[tuple(slice2)]) / 2.0).sum(axis)\n",
    "print(ret)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tupleset(t, i, value):\n",
    "    l = list(t)\n",
    "    l[i] = value\n",
    "    return tuple(l)\n",
    "\n",
    "y = np.array([9,8,7,6,5,4,3,2,1])\n",
    "x = np.array([1,3,1,1])\n",
    "axis = -1\n",
    "dx = 1\n",
    "\n",
    "N = y.shape[axis]\n",
    "start = 0\n",
    "stop = N - 2\n",
    "step = 2\n",
    "\n",
    "nd = len(y.shape)\n",
    "if start is None:\n",
    "    start = 0\n",
    "step = 2\n",
    "slice_all = (slice(None),)*nd\n",
    "slice0 = tupleset(slice_all, axis, slice(start, stop, step))\n",
    "slice1 = tupleset(slice_all, axis, slice(start+1, stop+1, step))\n",
    "slice2 = tupleset(slice_all, axis, slice(start+2, stop+2, step))\n",
    "\n",
    "print(slice_all)\n",
    "print(slice0)\n",
    "print(slice1)\n",
    "print(slice2)\n",
    "\n",
    "print(y[slice0])\n",
    "print(y[slice1])\n",
    "print(y[slice2])\n",
    "\n",
    "def _basic_simps(y, start, stop, x, dx, axis):\n",
    "    nd = len(y.shape)\n",
    "    if start is None:\n",
    "        start = 0\n",
    "    step = 2\n",
    "    slice_all = (slice(None),)*nd\n",
    "    slice0 = tupleset(slice_all, axis, slice(start, stop, step))\n",
    "    slice1 = tupleset(slice_all, axis, slice(start+1, stop+1, step))\n",
    "    slice2 = tupleset(slice_all, axis, slice(start+2, stop+2, step))\n",
    "\n",
    "    if x is None:  # Even spaced Simpson's rule.\n",
    "        result = np.sum(dx/3.0 * (y[slice0]+4*y[slice1]+y[slice2]),\n",
    "                        axis=axis)\n",
    "    else:\n",
    "        # Account for possibly different spacings.\n",
    "        #    Simpson's rule changes a bit.\n",
    "        h = np.diff(x, axis=axis)\n",
    "        sl0 = tupleset(slice_all, axis, slice(start, stop, step))\n",
    "        sl1 = tupleset(slice_all, axis, slice(start+1, stop+1, step))\n",
    "        h0 = h[sl0]\n",
    "        h1 = h[sl1]\n",
    "        hsum = h0 + h1\n",
    "        hprod = h0 * h1\n",
    "        h0divh1 = h0 / h1\n",
    "        tmp = hsum/6.0 * (y[slice0]*(2-1.0/h0divh1) +\n",
    "                          y[slice1]*hsum*hsum/hprod +\n",
    "                          y[slice2]*(2-h0divh1))\n",
    "        result = np.sum(tmp, axis=axis)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import integrate\n",
    "\n",
    "axis = -1\n",
    "dx = 1\n",
    "print(integrate.simps(y))\n",
    "\n",
    "x = np.arange(0, 10)\n",
    "y = np.arange(0, 10)\n",
    "\n",
    "N = y.shape[axis]\n",
    "start = 0\n",
    "stop = N - 2\n",
    "step = 2\n",
    "axis = -1\n",
    "dx = 1\n",
    "\n",
    "print(integrate.simps(y, x=x))\n",
    "print(integrate.trapz(y, x=x))\n",
    "\n",
    "print(_basic_simps(y, start, stop, x, dx, axis))\n",
    "\n",
    "x = np.asarray(x)\n",
    "if len(x.shape) == 1:\n",
    "    shapex = [1] * nd\n",
    "    shapex[axis] = x.shape[0]\n",
    "    saveshape = x.shape\n",
    "    returnshape = 1\n",
    "    x = x.reshape(tuple(shapex))\n",
    "print(x)\n",
    "\n",
    "print(_basic_simps(y, start, stop, x, dx, axis))\n",
    "\n",
    "print(N % 2 == 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "slice1 = (slice(None),)*nd\n",
    "slice2 = (slice(None),)*nd\n",
    "\n",
    "print(x)\n",
    "\n",
    "print(tupleset(slice1, axis, 0))\n",
    "print(tupleset(slice2, axis, 1))\n",
    "\n",
    "print(x[tuple(tupleset(slice1, axis, 0))])\n",
    "print(x[tuple(tupleset(slice1, axis, 1))])\n",
    "\n",
    "print(tupleset(slice1, axis, -1))\n",
    "print(tupleset(slice2, axis, -2))\n",
    "print(x[tuple(tupleset(slice1, axis, -1))])\n",
    "print(x[tuple(tupleset(slice2, axis, -2))])\n",
    "\n",
    "x = 0.0\n",
    "\n",
    "x += np.array([1,2,3])\n",
    "print(x + 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-2, 2, num=20)\n",
    "y = x\n",
    "y_int = integrate.cumtrapz(y, x, initial=0)\n",
    "print(y_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.array([1, 2, 3])\n",
    "print(integrate.cumtrapz(y))\n",
    "print(integrate.cumtrapz(y, initial=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi, 100)\n",
    "y = np.sin(x)\n",
    "\n",
    "dy = np.zeros(y.shape,np.float)\n",
    "print(dy)\n",
    "dy[0:-1] = np.diff(y)/np.diff(x)\n",
    "print(dy)\n",
    "dy[-1] = (y[-1] - y[-2])/(x[-1] - x[-2])\n",
    "dy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "nyq = 1\n",
    "cutoff = [0.1, 0.2, 0.3, 0.4]\n",
    "\n",
    "cutoff = np.atleast_1d(cutoff) / float(nyq)\n",
    "\n",
    "band = cutoff.reshape(-1, 2)\n",
    "print(band)\n",
    "\n",
    "for l, r in band:\n",
    "    print(l, r)\n",
    "\n",
    "pass_zero = False\n",
    "\n",
    "print(cutoff.size)\n",
    "print(cutoff.size & 1)\n",
    "\n",
    "print(True ^ True)\n",
    "\n",
    "pass_nyquist = bool(cutoff.size & 1) ^ pass_zero\n",
    "\n",
    "print(pass_nyquist)\n",
    "\n",
    "print([0.0] * False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.sinc([0.5 * np.pi, np.pi, (3 / 2) * np.pi, 2 * np.pi])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy as sp\n",
    "sp.special.i0([0, 100, 0, 100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1,2,3]\n",
    "x[:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.38777878e-17,  4.02128624e-02,  2.00770143e-01,  5.09787138e-01,\n",
       "        8.49229857e-01,  1.00000000e+00,  8.49229857e-01,  5.09787138e-01,\n",
       "        2.00770143e-01,  4.02128624e-02])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy import signal\n",
    "window = signal.kaiser(51, beta=14)\n",
    "window \n",
    "\n",
    "window = signal.kaiser(51, beta=14, sym=False)\n",
    "window\n",
    "\n",
    "signal.get_window(('kaiser', 4.0), 9)\n",
    "\n",
    "signal.get_window(4.0, 9)\n",
    "\n",
    "signal.get_window('black', 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "cutoff = np.array([0.5])\n",
    "np.any(np.diff(cutoff))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://stackoverflow.com/questions/1987694/how-to-print-the-full-numpy-array-without-truncation\n",
    "import sys\n",
    "import numpy as np\n",
    "from scipy import signal as sg\n",
    "import matplotlib.pyplot as plt\n",
    "np.set_printoptions(threshold=sys.maxsize)\n",
    "\n",
    "def plotSinal(t, x):\n",
    "    plt.plot(t, x)\n",
    "    plt.ylabel('Amplitude')\n",
    "    plt.xlabel('Tempo (s)')\n",
    "    plt.xlim(0, 10)\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# generate the signals\n",
    "N = 50.0\n",
    "fs = 128\n",
    "n = np.linspace(0, N, num= int(N*fs), endpoint=False)\n",
    "\n",
    "f1 = 1 # 1Hz\n",
    "sg1 = np.sin(n*2*np.pi*f1)\n",
    "\n",
    "f2 = 10 # 10Hz\n",
    "sg2 = np.sin(n*2*np.pi*f2)\n",
    "\n",
    "sgF = sg1 + sg2\n",
    "\n",
    "# print(sg1)\n",
    "# print(sg2)\n",
    "# print(sgF)\n",
    "# print(n)\n",
    "\n",
    "# design filter\n",
    "nyq = 0.5 * fs\n",
    "fc = 1\n",
    "normal_fc = fc / nyq\n",
    "numtaps = 30\n",
    "b = sg.firwin(numtaps, [normal_fc])\n",
    "\n",
    "# filter the signal\n",
    "sgFiltered = sg.lfilter(b, [1.0], sgF)\n",
    "\n",
    "# sgFiltered\n",
    "\n",
    "# plotSinal(n, sg1)\n",
    "# plotSinal(n, sgF)\n",
    "# plotSinal(n, sgFiltered)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "np.log10([0.1, 1, 10, 100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "100\n",
      "51\n",
      "51\n",
      "(array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1, 1.2,\n",
      "       1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. , 2.1, 2.2, 2.3, 2.4, 2.5,\n",
      "       2.6, 2.7, 2.8, 2.9, 3. , 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8,\n",
      "       3.9, 4. , 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5. ]), array([-396.82385374, -401.33202052, -407.04917523, -415.43286071,\n",
      "       -402.80353597, -399.06105916, -403.76851492, -402.76164868,\n",
      "       -402.73285387, -402.06646097,  -90.3089987 , -396.29726491,\n",
      "       -401.81175052, -405.28609821, -413.42907823, -397.75441859,\n",
      "       -400.65583836, -403.14740317, -399.9349631 , -401.81347237,\n",
      "       -400.64236041, -397.59508689, -409.42546121, -410.31589832,\n",
      "       -403.98704145, -398.3382704 , -397.01763828, -415.52306087,\n",
      "       -403.5856551 , -401.83539856, -392.08781713, -402.99382545,\n",
      "       -396.5412601 , -405.43547178, -402.78279116, -398.2455716 ,\n",
      "       -401.79845354, -406.38899573, -397.79290681, -397.6235298 ,\n",
      "       -405.31839445, -402.71049484, -402.8673643 , -407.16057593,\n",
      "       -400.39101984, -399.69644255, -398.75944677, -400.92954176,\n",
      "       -400.73214384, -395.77550257, -400.50268472]))\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def dbfft(x, fs, win=None, ref=32768):\n",
    "    \"\"\"\n",
    "    Calculate spectrum in dB scale\n",
    "    Args:\n",
    "        x: input signal\n",
    "        fs: sampling frequency\n",
    "        win: vector containing window samples (same length as x).\n",
    "             If not provided, then rectangular window is used by default.\n",
    "        ref: reference value used for dBFS scale. 32768 for int16 and 1 for float\n",
    "\n",
    "    Returns:\n",
    "        freq: frequency vector\n",
    "        s_db: spectrum in dB scale\n",
    "    \"\"\"\n",
    "\n",
    "    N = len(x)  # Length of input sequence\n",
    "\n",
    "    if win is None:\n",
    "        win = np.ones(N)\n",
    "        print(len(win))\n",
    "    if len(x) != len(win):\n",
    "            raise ValueError('Signal and window must be of the same length')\n",
    "    x = x * win\n",
    "\n",
    "    # Calculate real FFT and frequency vector\n",
    "    sp = np.fft.rfft(x)\n",
    "#     sp = sp[:len(sp)//2]\n",
    "    freq = np.arange((N / 2) + 1) / (float(N) / fs)\n",
    "\n",
    "    # Scale the magnitude of FFT by window and factor of 2,\n",
    "    # because we are using half of FFT spectrum.\n",
    "    s_mag = np.abs(sp) * (2 / np.sum(win))\n",
    "\n",
    "    # Convert to dBFS\n",
    "    s_dbfs = 20 * np.log10(s_mag/ref)\n",
    "\n",
    "    return freq, s_dbfs\n",
    "\n",
    "# generate the signals\n",
    "N = 10.0\n",
    "fs = 10\n",
    "n = np.linspace(0, N, num= int(N*fs), endpoint=False)\n",
    "\n",
    "f1 = 1 # 1Hz\n",
    "sg1 = np.sin(n*2*np.pi*f1)\n",
    "\n",
    "print(len(sg1))\n",
    "\n",
    "dbs = dbfft(sg1, fs)\n",
    "print(len(dbs[0]))\n",
    "print(len(dbs[1]))\n",
    "print(dbs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.36171372e-14+0.00000000e+00j, -9.00541287e-15+1.07904914e-14j,\n",
       "        3.62254533e-15-6.31142149e-15j,  2.71761134e-15-5.45889252e-16j,\n",
       "        1.15561038e-14-2.68677154e-15j, -3.55247667e-16+1.82509185e-14j,\n",
       "       -8.61825328e-15-6.20019692e-15j,  9.93348561e-15+6.59183943e-15j,\n",
       "        1.15990293e-14-2.92138105e-15j, -5.90169617e-15+1.14877810e-14j,\n",
       "       -1.42108547e-14-5.00000000e+01j, -1.46545974e-14-2.03694215e-14j,\n",
       "       -1.77089966e-16-1.32982321e-14j,  6.90135294e-15-5.64324728e-15j,\n",
       "       -4.84270886e-16+3.45737917e-15j,  4.66128841e-15-2.06993876e-14j,\n",
       "        1.45703920e-14+4.30284012e-15j,  1.13594668e-14+1.00462979e-15j,\n",
       "        1.19369103e-14+1.14015692e-14j,  7.86242669e-15+1.07231746e-14j,\n",
       "        2.46566275e-15+1.50149484e-14j, -1.88187583e-14+1.06240163e-14j,\n",
       "       -5.39608870e-15-1.23392838e-15j, -4.96090167e-15-5.91412460e-16j,\n",
       "        9.68393922e-15+3.66152235e-15j, -3.99340142e-15+1.94323044e-14j,\n",
       "       -2.29295458e-14-2.76843378e-15j,  2.66489842e-15+6.50990959e-16j,\n",
       "        6.66942903e-15-8.54884322e-15j,  5.63715458e-16+1.32512667e-14j,\n",
       "       -3.90099173e-14+1.17488528e-14j,  5.37857614e-15-1.02858522e-14j,\n",
       "       -1.89571320e-14-1.53589379e-14j, -2.03953716e-15-8.52221639e-15j,\n",
       "       -2.88530594e-15-1.15373857e-14j,  3.25194357e-15-1.97857858e-14j,\n",
       "        1.31168472e-14-2.31625352e-15j,  4.03919598e-15-6.73319548e-15j,\n",
       "        1.90104678e-14-9.20990139e-15j,  1.53647114e-14+1.50961066e-14j,\n",
       "       -7.10542736e-15+5.32907052e-15j,  1.07202670e-14+5.37459841e-15j,\n",
       "       -1.09362265e-15+1.17265770e-14j, -7.03213846e-15-1.47132042e-15j,\n",
       "        1.46800666e-14+5.46062569e-15j,  2.55865110e-15+1.67726797e-14j,\n",
       "       -1.64435049e-14+9.31653272e-15j, -1.13369658e-14-9.39077069e-15j,\n",
       "       -1.49679805e-14+1.65843075e-15j,  2.07372360e-14-1.67337435e-14j,\n",
       "       -1.54627133e-14+0.00000000e+00j])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]);\n",
    "np.fft.rfft(x)\n",
    "\n",
    "# generate the signals\n",
    "N = 10.0\n",
    "fs = 10\n",
    "n = np.linspace(0, N, num= int(N*fs), endpoint=False)\n",
    "\n",
    "f1 = 1 # 1Hz\n",
    "x = np.sin(n*2*np.pi*f1)\n",
    "\n",
    "X = np.fft.rfft(x)\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}