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