Test_func.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def roll_zeropad(a, shift, axis=None):\n",
    "    a = np.asanyarray(a)\n",
    "\n",
    "    if shift == 0:\n",
    "        return a\n",
    "\n",
    "    if axis is None:\n",
    "        n = a.size\n",
    "        print(n)\n",
    "        reshape = True\n",
    "    else:\n",
    "        n = a.shape[axis]\n",
    "        reshape = False\n",
    "\n",
    "    if np.abs(shift) > n:\n",
    "        res = np.zeros_like(a)\n",
    "    elif shift < 0:\n",
    "        shift += n\n",
    "        zeros = np.zeros_like(a.take(np.arange(n-shift), axis))\n",
    "        print(zeros)\n",
    "        res = np.concatenate((a.take(np.arange(n-shift, n), axis), zeros), axis)\n",
    "        print(res)\n",
    "    else:\n",
    "        zeros = np.zeros_like(a.take(np.arange(n-shift, n), axis))\n",
    "        res = np.concatenate((zeros, a.take(np.arange(n-shift), axis)), axis)\n",
    "\n",
    "    if reshape:\n",
    "        return res.reshape(a.shape)\n",
    "    else:\n",
    "        return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [3, 4, 5],\n",
       "       [7, 8, 9],\n",
       "       [2, 3, 4]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1,2,3],[3,4,5],[7,8,9],[2,3,4]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0]\n",
      " [0 0 0]\n",
      " [0 0 0]\n",
      " [0 0 0]]\n",
      "[[0 0 0]\n",
      " [0 0 0]\n",
      " [0 0 0]\n",
      " [0 0 0]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [0, 0, 0],\n",
       "       [0, 0, 0],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roll_zeropad(a, -3, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import multiprocessing\n",
    "from numpy.random import randint\n",
    "from numpy.linalg import norm, eigh\n",
    "from numpy.fft import fft, ifft\n",
    "\n",
    "def _ncc_c_3dim(data):\n",
    "    x, y = data[0], data[1]\n",
    "    # norm is correct den is correct\n",
    "    den = norm(x, axis=(0, 1)) * norm(y, axis=(0, 1))\n",
    "    # Why???\n",
    "    if den < 1e-9:\n",
    "        den = np.inf\n",
    "\n",
    "    x_len = x.shape[0]\n",
    "    print(x_len)\n",
    "    fft_size = 1 << (2*x_len-1).bit_length()\n",
    "\n",
    "    cc = ifft(fft(x, fft_size, axis=0) * np.conj(fft(y, fft_size, axis=0)), axis=0)\n",
    "    cc = np.concatenate((cc[-(x_len-1):], cc[:x_len]), axis=0)\n",
    "\n",
    "    return np.real(cc).sum(axis=-1) / den"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1, 2, 3],\n",
       "        [3, 4, 5]],\n",
       "\n",
       "       [[5, 6, 7],\n",
       "        [7, 8, 9]]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.array([[[1,2,3],[3,4,5]],[[5,6,7],[7,8,9]]])\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.35846208, 0.97501687, 0.53052388])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_ncc_c_3dim(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _ncc_c_3dim(data):\n",
    "    x, y = data[0], data[1]\n",
    "    den = norm(x, axis=(0, 1)) * norm(y, axis=(0, 1))\n",
    "    # Why do we need this??\n",
    "    if den < 1e-9:\n",
    "        den = np.inf\n",
    "    # I believe that if dimension is 2 for x and y, we should use fft2 and ifft2. For 2 dim, I believe that the result should be a larger matrix.\n",
    "    # also, I think univariate should be separated from multivariate instead of adding extra axis.\n",
    "\n",
    "    # I believe that padding along axis = 0 is incorrect. Because, in multivariate case, axis = 0 represents how many time series and we shouldn't add new time series. shape[1]\n",
    "    # ??????? Need to be discussed\n",
    "    x_len = x.shape[0]\n",
    "    fft_size = 1 << (2*x_len-1).bit_length()\n",
    "\n",
    "    cc = ifft(fft(x, fft_size, axis=0) * np.conj(fft(y, fft_size, axis=0)), axis=0)\n",
    "    cc = np.concatenate((cc[-(x_len-1):], cc[:x_len]), axis=0)\n",
    "\n",
    "    return np.real(cc).sum(axis=-1) #/ den"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]]),\n",
       " array([[1],\n",
       "        [1],\n",
       "        [1],\n",
       "        [0]]))"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# x = np.array([[1,2,3,4],[5,6,7,8],[9,1,2,3]]).T\n",
    "# y = np.array([[1,1,1,0],[1,1,1,0],[1,1,1,0]]).T\n",
    "x = np.array([[1,2,3,4]]).T\n",
    "y = np.array([[1,1,1,0]]).T\n",
    "\n",
    "x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 3., 6., 9., 7., 4.])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_ncc_c_3dim([x,y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}