{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Timing for QobjEvo\n",
    "\n",
    "Made by Eric Giguere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import qutip as qt\n",
    "import numpy as np\n",
    "from qutip import QobjEvo\n",
    "%load_ext cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10\n",
    "destroy, create, Id = qt.destroy(N), qt.create(N), qt.qeye(N)\n",
    "def exp_i(t,args):\n",
    "    return np.exp(-1j*t)\n",
    "def cos_w(t,args):\n",
    "    return np.cos(args[\"w\"]*t)\n",
    "tlist = np.linspace(0,10,10000)\n",
    "tlistlog = np.logspace(-3,1,10000)\n",
    "\n",
    "# state vector as np array\n",
    "vec = np.arange(N)*.5+.5j\n",
    "vec_super = np.arange(N**2)*.5+.5j\n",
    "mat_c = (np.arange(N**2)*.5+.5j).reshape((10,10))\n",
    "mat_f = np.asfortranarray(mat_c*1.)\n",
    "\n",
    "# Construct QobjEvo of all type\n",
    "td_cte1 = QobjEvo(Id)\n",
    "td_cte2 = QobjEvo([Id])\n",
    "\n",
    "td_func = QobjEvo([Id,[create,exp_i],[destroy,cos_w]],args={\"w\":2})\n",
    "td_str = QobjEvo([Id,[create,\"exp(-1j*t)\"],[destroy,\"cos(w*t)\"]],args={'w':2.})\n",
    "td_array = QobjEvo([Id,[create,np.exp(-1j*tlist)],[destroy,np.cos(2*tlist)]],tlist=tlist)\n",
    "td_array_log = QobjEvo([Id,[create,np.exp(-1j*tlistlog)],[destroy,np.cos(2*tlistlog)]],tlist=tlistlog)\n",
    "\n",
    "td_super = qt.liouvillian(td_func, c_ops=td_cte1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timing: call\n",
    "\n",
    "Timing check for all coeff formats.  \n",
    "Once compiled, the cython method is called by the usual method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time for cte\n",
      "31.5 µs ± 442 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "7.3 µs ± 115 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "Time for compiled cte\n",
      "32.3 µs ± 737 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "7.18 µs ± 60.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# The compiled version build the scipy object from the sparce matrix if not used with data=True\n",
    "print(\"Time for cte\")\n",
    "td_cte1.compiled = False\n",
    "%timeit td_cte1(2)\n",
    "%timeit td_cte1(2, data=True)\n",
    "print(\"Time for compiled cte\")\n",
    "td_cte1.compile()\n",
    "%timeit td_cte1(2)\n",
    "%timeit td_cte1(2, data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time for str\n",
      "453 µs ± 18.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "140 µs ± 1.11 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "45.9 µs ± 3.69 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "9.67 µs ± 306 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"Time for str\")\n",
    "td_str.compiled = False\n",
    "%timeit td_str(2)\n",
    "%timeit td_str(2, data=True)\n",
    "td_str.compile()\n",
    "%timeit td_str(2)\n",
    "%timeit td_str(2, data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time for function\n",
      "394 µs ± 7.31 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "103 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "50.2 µs ± 464 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "13.5 µs ± 551 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"Time for function\")\n",
    "td_func.compiled = False\n",
    "%timeit td_func(2)\n",
    "%timeit td_func(2, data=True)\n",
    "td_func.compile()\n",
    "%timeit td_func(2)\n",
    "%timeit td_func(2, data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time for array\n",
      "443 µs ± 12.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "166 µs ± 25.8 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "47 µs ± 2.91 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "9.54 µs ± 190 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"Time for array\")\n",
    "td_array.compiled = False\n",
    "%timeit td_array(2)\n",
    "%timeit td_array(2, data=True)\n",
    "td_array.compile()\n",
    "%timeit td_array(2)\n",
    "%timeit td_array(2, data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time for array with variable time step\n",
      "447 µs ± 7.13 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "145 µs ± 2.71 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "44.8 µs ± 532 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "9.57 µs ± 168 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"Time for array with variable time step\")\n",
    "td_array_log.compiled = False\n",
    "%timeit td_array_log(2)\n",
    "%timeit td_array_log(2, data=True)\n",
    "td_array_log.compile()\n",
    "%timeit td_array_log(2)\n",
    "%timeit td_array_log(2, data=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timing: multiplication with a vector\n",
    "The QobjEvo at t x vec, used by most solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for rhs: cte\n",
      "13.6 µs ± 133 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "4.51 µs ± 63.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "16.2 µs ± 77.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "4.18 µs ± 35.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for rhs: cte\")\n",
    "td_cte1.compiled = False\n",
    "%timeit qt.cy.spmv(td_cte1(2, data=True), vec)\n",
    "%timeit qt.cy.spmv(Id.data, vec)\n",
    "%timeit td_cte1.mul_vec(2,vec)\n",
    "td_cte1.compile()\n",
    "%timeit td_cte1.mul_vec(2,vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for rhs: str\n",
      "157 µs ± 1.82 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "160 µs ± 1.04 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "5.39 µs ± 53.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for rhs: str\")\n",
    "td_str.compiled = False\n",
    "%timeit qt.cy.spmv(td_str(2, data=True), vec)\n",
    "%timeit td_str.mul_vec(2,vec)\n",
    "td_str.compile()\n",
    "%timeit td_str.mul_vec(2,vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for rhs: cte\n",
      "115 µs ± 999 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "129 µs ± 10.2 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "12.1 µs ± 2.23 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for rhs: cte\")\n",
    "td_func.compiled = False\n",
    "%timeit qt.cy.spmv(td_func(2, data=True), vec)\n",
    "%timeit td_func.mul_vec(2,vec)\n",
    "td_func.compile()\n",
    "%timeit td_func.mul_vec(2,vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for rhs: cte\n",
      "160 µs ± 6.56 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "162 µs ± 6.32 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "6.1 µs ± 565 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for rhs: cte\")\n",
    "td_array.compiled = False\n",
    "%timeit qt.cy.spmv(td_array(2, data=True), vec)\n",
    "%timeit td_array.mul_vec(2,vec)\n",
    "td_array.compile()\n",
    "%timeit td_array.mul_vec(2,vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for rhs: cte\n",
      "170 µs ± 17.1 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "157 µs ± 1.65 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "5.66 µs ± 169 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for rhs: cte\")\n",
    "td_array_log.compiled = False\n",
    "%timeit qt.cy.spmv(td_array_log(2, data=True), vec)\n",
    "%timeit td_array_log.mul_vec(2,vec)\n",
    "td_array_log.compile()\n",
    "%timeit td_array_log.mul_vec(2,vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timing: multiplication with matrix\n",
    "QobjEvo at t time same shape matrix, used for operator evolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for mul_mat: c format sparce\n",
      "159 µs ± 4 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "164 µs ± 2.2 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "8.41 µs ± 109 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for mul_mat: c format sparce\")\n",
    "td_str.compiled = False\n",
    "%timeit td_str(2, data=True) * mat_c\n",
    "%timeit td_str.mul_mat(2,mat_c)\n",
    "td_str.compile()\n",
    "%timeit td_str.mul_mat(2,mat_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for mul_mat: c format dense\n",
      "156 µs ± 1.31 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "162 µs ± 1.23 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "9.15 µs ± 99.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for mul_mat: c format dense\")\n",
    "td_str.compiled = False\n",
    "%timeit td_str(2, data=True) * mat_c\n",
    "%timeit td_str.mul_mat(2,mat_c)\n",
    "td_str.compile(dense=True)\n",
    "%timeit td_str.mul_mat(2,mat_c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for mul_mat: f format sparce\n",
      "159 µs ± 1.81 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "170 µs ± 4.01 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "6.25 µs ± 76.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for mul_mat: f format sparce\")\n",
    "td_str.compiled = False\n",
    "%timeit td_str(2, data=True) * mat_f\n",
    "%timeit td_str.mul_mat(2,mat_f)\n",
    "td_str.compile()\n",
    "%timeit td_str.mul_mat(2,mat_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for mul_mat: f format dense\n",
      "159 µs ± 2.91 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "171 µs ± 6.09 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "10.2 µs ± 432 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for mul_mat: f format dense\")\n",
    "td_str.compiled = False\n",
    "%timeit td_str(2, data=True) * mat_f\n",
    "%timeit td_str.mul_mat(2,mat_f)\n",
    "td_str.compile(dense=True)\n",
    "%timeit td_str.mul_mat(2,mat_f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timing: expect\n",
    "expectation value of QobjEvo(t) and psi/rho"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for expect: cte\n",
      "11.4 µs ± 92.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "16.2 µs ± 264 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "5.56 µs ± 63.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for expect: cte\")\n",
    "td_cte1.compiled = False\n",
    "%timeit qt.cy.cy_expect_psi(td_cte1(2, data=True), vec, 0)\n",
    "%timeit td_cte1.expect(2,vec,0)\n",
    "td_cte1.compile()\n",
    "%timeit td_cte1.expect(2,vec,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for expect: str\n",
      "152 µs ± 1.35 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "163 µs ± 2.68 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "6.92 µs ± 61.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for expect: str\")\n",
    "td_str.compiled = False\n",
    "%timeit qt.cy.cy_expect_psi(td_str(2, data=True), vec, 0)\n",
    "%timeit td_str.expect(2,vec,0)\n",
    "td_str.compile()\n",
    "%timeit td_str.expect(2,vec,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for expect: func\n",
      "119 µs ± 4.36 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "121 µs ± 3.62 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "12.1 µs ± 393 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for expect: func\")\n",
    "td_func.compiled = False\n",
    "%timeit qt.cy.cy_expect_psi(td_func(2, data=True), vec, 0)\n",
    "%timeit td_func.expect(2,vec,0)\n",
    "td_func.compile()\n",
    "%timeit td_func.expect(2,vec,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for expect: array\n",
      "200 µs ± 46.8 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "163 µs ± 7.36 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "10.1 µs ± 2.1 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for expect: array\")\n",
    "td_array.compiled = False\n",
    "%timeit qt.cy.cy_expect_psi(td_array(2, data=True), vec, 0)\n",
    "%timeit td_array.expect(2,vec,0)\n",
    "td_array.compile()\n",
    "%timeit td_array.expect(2,vec,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for expect: array logscale\n",
      "156 µs ± 7.88 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "158 µs ± 4.11 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "7.14 µs ± 40.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for expect: array logscale\")\n",
    "td_array_log.compiled = False\n",
    "%timeit qt.cy.cy_expect_psi(td_array_log(2, data=True), vec, 0)\n",
    "%timeit td_array_log.expect(2,vec,0)\n",
    "td_array_log.compile()\n",
    "%timeit td_array_log.expect(2,vec,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for expect_rho: func\n",
      "121 µs ± 1.99 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "127 µs ± 579 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "9.28 µs ± 67.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for expect_rho: func\")\n",
    "td_super.compiled = False\n",
    "%timeit qt.cy.cy_expect_rho_vec(td_super(2, data=True), vec_super, 0)\n",
    "%timeit td_super.expect(2,vec_super,0)\n",
    "td_super.compile()\n",
    "%timeit td_super.expect(2,vec_super,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timing: call with other arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "td_args = QobjEvo([Id,[destroy,cos_w]],args={\"w\":1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for function\n",
      "212 µs ± 3.18 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "207 µs ± 1.65 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "60.2 µs ± 2.19 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "62.1 µs ± 2.68 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "225 µs ± 19.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "47 µs ± 487 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "58.5 µs ± 838 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "10.9 µs ± 139 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for function\")\n",
    "%timeit td_args(2, args={\"w\":2})\n",
    "%timeit td_args(2)\n",
    "%timeit td_args(2, args={\"w\":2}, data=True)\n",
    "%timeit td_args(2, data=True)\n",
    "td_args.compile()\n",
    "%timeit td_args(2, args={\"w\":2})\n",
    "%timeit td_args(2)\n",
    "%timeit td_args(2, args={\"w\":2}, data=True)\n",
    "%timeit td_args(2, data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "td_args = QobjEvo([Id,[destroy,\"cos(w*t)\"]],args={\"w\":1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "timing for string\n",
      "251 µs ± 5.55 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "244 µs ± 11.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "76.7 µs ± 493 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "74.3 µs ± 834 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "245 µs ± 6.85 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "44 µs ± 1.36 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "76.4 µs ± 518 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "8.37 µs ± 86 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "print(\"timing for string\")\n",
    "%timeit td_args(2, args={\"w\":2})\n",
    "%timeit td_args(2)\n",
    "%timeit td_args(2, args={\"w\":2}, data=True)\n",
    "%timeit td_args(2, data=True)\n",
    "td_args.compile()\n",
    "%timeit td_args(2, args={\"w\":2})\n",
    "%timeit td_args(2)\n",
    "%timeit td_args(2, args={\"w\":2}, data=True)\n",
    "%timeit td_args(2, data=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timing: call that depends on state\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68.2 µs ± 2.79 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "17.7 µs ± 409 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "def coeff_state(t, args):\n",
    "    return np.max(args[\"vec\"])*args[\"w\"]\n",
    "td_state = QobjEvo([Id, [destroy, coeff_state]],args={\"w\":1,\"vec=vec\":vec})\n",
    "%timeit td_state(2, state=vec, data=True)\n",
    "td_state.compile()\n",
    "%timeit td_state(2, state=vec, data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "76.4 µs ± 673 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "17.5 µs ± 162 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "def coeff_state(t, args):\n",
    "    return args[\"e1\"]\n",
    "td_state = QobjEvo([Id, [destroy, coeff_state]], args={\"e1=expect\":qt.qeye(N)})\n",
    "%timeit td_state(2, state=vec, data=True)\n",
    "td_state.compile()\n",
    "%timeit td_state(2, state=vec, data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "93 µs ± 772 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "17.1 µs ± 341 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "td_state = QobjEvo([Id, [destroy, \"e1\"]], args={\"e1=expect\":qt.qeye(N)})\n",
    "%timeit td_state(2, state=vec, data=True)\n",
    "td_state.compile()\n",
    "%timeit td_state(2, state=vec, data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "QuTiP: Quantum Toolbox in Python\n",
      "Copyright (c) 2011 and later.\n",
      "A. J. Pitchford, P. D. Nation, R. J. Johansson, A. Grimsmo, and C. Granade\n",
      "\n",
      "QuTiP Version:      4.4.0.dev0+1a639d7a\n",
      "Numpy Version:      1.16.3\n",
      "Scipy Version:      1.2.1\n",
      "Cython Version:     0.29.7\n",
      "Matplotlib Version: 3.0.3\n",
      "Python Version:     3.7.3\n",
      "Number of CPUs:     2\n",
      "BLAS Info:          INTEL MKL\n",
      "OPENMP Installed:   False\n",
      "INTEL MKL Ext:      True\n",
      "Platform Info:      Darwin (x86_64)\n",
      "Installation path:  /Users/nathanshammah/miniconda3/envs/qobjevo/lib/python3.7/site-packages/qutip-4.4.0.dev0+1a639d7a-py3.7-macosx-10.7-x86_64.egg/qutip\n",
      "==============================================================================\n",
      "Please cite QuTiP in your publication.\n",
      "==============================================================================\n",
      "For your convenience a bibtex reference can be easily generated using `qutip.cite()`\n"
     ]
    }
   ],
   "source": [
    "qt.about()"
   ]
  }
 ],
 "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
}